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 = strdup; ///< Use strdup instead of SWIGRegisterStringCallback_NDalic.
 277
 278
 279 #ifdef __cplusplus
 280 extern "C"
 281 #endif
 282 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 283   // Let we don't use registered string callback. Instead, use strdup. Since 2024-02-21.
 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   void * jwindow  ;
1199
1200   if (!swig_callbackOnCreate) {
1201     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1202     return;
1203   } else {
1204     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1205     swig_callbackOnCreate(contentInfo.c_str(), jwindow);
1206   }
1207 }
1208
1209 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1210   int jtype  ;
1211
1212   if (!swig_callbackOnTerminate) {
1213     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1214     return;
1215   } else {
1216     jtype = (int)type;
1217     swig_callbackOnTerminate(contentInfo.c_str(), jtype);
1218   }
1219 }
1220
1221 void SwigDirector_WidgetImpl::OnPause() {
1222   if (!swig_callbackOnPause) {
1223     Dali::Internal::Adaptor::Widget::OnPause();
1224     return;
1225   } else {
1226     swig_callbackOnPause();
1227   }
1228 }
1229
1230 void SwigDirector_WidgetImpl::OnResume() {
1231   if (!swig_callbackOnResume) {
1232     Dali::Internal::Adaptor::Widget::OnResume();
1233     return;
1234   } else {
1235     swig_callbackOnResume();
1236   }
1237 }
1238
1239 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1240   void * jwindow  ;
1241
1242   if (!swig_callbackOnResize) {
1243     Dali::Internal::Adaptor::Widget::OnResize(window);
1244     return;
1245   } else {
1246     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1247     swig_callbackOnResize(jwindow);
1248   }
1249 }
1250
1251 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1252   int jforce  ;
1253
1254   if (!swig_callbackOnUpdate) {
1255     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1256     return;
1257   } else {
1258     jforce = force;
1259     swig_callbackOnUpdate(contentInfo.c_str(), jforce);
1260   }
1261 }
1262
1263 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1264   void * jslotObserver = 0 ;
1265   void * jcallback = 0 ;
1266
1267   if (!swig_callbackSignalConnected) {
1268     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1269     return;
1270   } else {
1271     jslotObserver = (void *) slotObserver;
1272     jcallback = (void *) callback;
1273     swig_callbackSignalConnected(jslotObserver, jcallback);
1274   }
1275 }
1276
1277 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1278   void * jslotObserver = 0 ;
1279   void * jcallback = 0 ;
1280
1281   if (!swig_callbackSignalDisconnected) {
1282     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1283     return;
1284   } else {
1285     jslotObserver = (void *) slotObserver;
1286     jcallback = (void *) callback;
1287     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1288   }
1289 }
1290
1291 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) {
1292
1293   swig_callbackOnCreate = callbackOnCreate;
1294   swig_callbackOnTerminate = callbackOnTerminate;
1295   swig_callbackOnPause = callbackOnPause;
1296   swig_callbackOnResume = callbackOnResume;
1297   swig_callbackOnResize = callbackOnResize;
1298   swig_callbackOnUpdate = callbackOnUpdate;
1299   swig_callbackSignalConnected = callbackSignalConnected;
1300   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1301 }
1302
1303 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1304   swig_callbackOnCreate = 0;
1305   swig_callbackOnTerminate = 0;
1306   swig_callbackOnPause = 0;
1307   swig_callbackOnResume = 0;
1308   swig_callbackOnResize = 0;
1309   swig_callbackOnUpdate = 0;
1310   swig_callbackSignalConnected = 0;
1311   swig_callbackSignalDisconnected = 0;
1312 }
1313
1314
1315 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1316   swig_init_callbacks();
1317 }
1318
1319 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1320
1321 }
1322
1323
1324 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1325   int jdepth  ;
1326
1327   if (!swig_callbackOnSceneConnection) {
1328     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1329     return;
1330   } else {
1331     jdepth = depth;
1332     swig_callbackOnSceneConnection(jdepth);
1333   }
1334 }
1335
1336 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1337   if (!swig_callbackOnSceneDisconnection) {
1338     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1339     return;
1340   } else {
1341     swig_callbackOnSceneDisconnection();
1342   }
1343 }
1344
1345 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1346   void * jchild = 0 ;
1347
1348   if (!swig_callbackOnChildAdd) {
1349     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1350     return;
1351   } else {
1352     jchild = (Dali::Actor *) &child;
1353     swig_callbackOnChildAdd(jchild);
1354   }
1355 }
1356
1357 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1358   void * jchild = 0 ;
1359
1360   if (!swig_callbackOnChildRemove) {
1361     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1362     return;
1363   } else {
1364     jchild = (Dali::Actor *) &child;
1365     swig_callbackOnChildRemove(jchild);
1366   }
1367 }
1368
1369 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) {
1370   int jindex  ;
1371
1372   if (!swig_callbackOnPropertySet) {
1373     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1374     return;
1375   } else {
1376     jindex = index;
1377     swig_callbackOnPropertySet(jindex, (Dali::Property::Value*)&propertyValue);
1378   }
1379 }
1380
1381 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1382   void * jtargetSize = 0 ;
1383
1384   if (!swig_callbackOnSizeSet) {
1385     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1386     return;
1387   } else {
1388     jtargetSize = (Dali::Vector3 *) &targetSize;
1389     swig_callbackOnSizeSet(jtargetSize);
1390   }
1391 }
1392
1393 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1394   void * janimation = 0 ;
1395   void * jtargetSize = 0 ;
1396
1397   if (!swig_callbackOnSizeAnimation) {
1398     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1399     return;
1400   } else {
1401     janimation = (Dali::Animation *) &animation;
1402     jtargetSize = (Dali::Vector3 *) &targetSize;
1403     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1404   }
1405 }
1406
1407 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1408   bool c_result = SwigValueInit< bool >() ;
1409   unsigned int jresult = 0 ;
1410   void * jarg0 = 0 ;
1411
1412   if (!swig_callbackOnKeyEvent) {
1413     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1414   } else {
1415     jarg0 = (Dali::KeyEvent *) &event;
1416     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1417     c_result = jresult ? true : false;
1418   }
1419   return c_result;
1420 }
1421
1422 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1423   void * jsize = 0 ;
1424   void * jcontainer = 0 ;
1425
1426   if (!swig_callbackOnRelayout) {
1427     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1428     return;
1429   } else {
1430     jsize = (Dali::Vector2 *) &size;
1431     jcontainer = (Dali::RelayoutContainer *) &container;
1432     swig_callbackOnRelayout(jsize, jcontainer);
1433   }
1434 }
1435
1436 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1437   int jpolicy  ;
1438   int jdimension  ;
1439
1440   if (!swig_callbackOnSetResizePolicy) {
1441     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1442     return;
1443   } else {
1444     jpolicy = (int)policy;
1445     jdimension = (int)dimension;
1446     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1447   }
1448 }
1449
1450 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1451   Dali::Vector3 c_result ;
1452   void * jresult = 0 ;
1453
1454   if (!swig_callbackGetNaturalSize) {
1455     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1456   } else {
1457     jresult = (void *) swig_callbackGetNaturalSize();
1458     if (!jresult) {
1459       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1460       return c_result;
1461     }
1462     c_result = *(Dali::Vector3 *)jresult;
1463   }
1464   return c_result;
1465 }
1466
1467 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1468   float c_result = SwigValueInit< float >() ;
1469   float jresult = 0 ;
1470   void * jchild = 0 ;
1471   int jdimension  ;
1472
1473   if (!swig_callbackCalculateChildSize) {
1474     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1475   } else {
1476     jchild = (Dali::Actor *) &child;
1477     jdimension = (int)dimension;
1478     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1479     c_result = (float)jresult;
1480   }
1481   return c_result;
1482 }
1483
1484 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1485   float c_result = SwigValueInit< float >() ;
1486   float jresult = 0 ;
1487   float jwidth  ;
1488
1489   if (!swig_callbackGetHeightForWidth) {
1490     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1491   } else {
1492     jwidth = width;
1493     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1494     c_result = (float)jresult;
1495   }
1496   return c_result;
1497 }
1498
1499 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1500   float c_result = SwigValueInit< float >() ;
1501   float jresult = 0 ;
1502   float jheight  ;
1503
1504   if (!swig_callbackGetWidthForHeight) {
1505     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1506   } else {
1507     jheight = height;
1508     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1509     c_result = (float)jresult;
1510   }
1511   return c_result;
1512 }
1513
1514 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1515   bool c_result = SwigValueInit< bool >() ;
1516   unsigned int jresult = 0 ;
1517   int jdimension  ;
1518
1519   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1520     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1521   } else {
1522     jdimension = (int)dimension;
1523     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1524     c_result = jresult ? true : false;
1525   }
1526   return c_result;
1527 }
1528
1529 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1530   int jdimension  ;
1531
1532   if (!swig_callbackOnCalculateRelayoutSize) {
1533     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1534     return;
1535   } else {
1536     jdimension = (int)dimension;
1537     swig_callbackOnCalculateRelayoutSize(jdimension);
1538   }
1539 }
1540
1541 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1542   float jsize  ;
1543   int jdimension  ;
1544
1545   if (!swig_callbackOnLayoutNegotiated) {
1546     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1547     return;
1548   } else {
1549     jsize = size;
1550     jdimension = (int)dimension;
1551     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1552   }
1553 }
1554
1555 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1556   return Dali::CustomActorImpl::GetExtension();
1557 }
1558
1559 void SwigDirector_ViewImpl::OnInitialize() {
1560   if (!swig_callbackOnInitialize) {
1561     Dali::Toolkit::Internal::Control::OnInitialize();
1562     return;
1563   } else {
1564     swig_callbackOnInitialize();
1565   }
1566 }
1567
1568 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1569   int jchange  ;
1570
1571   if (!swig_callbackOnStyleChange) {
1572     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1573     return;
1574   } else {
1575     jchange = (int)change;
1576     swig_callbackOnStyleChange((Dali::Toolkit::StyleManager*)&styleManager, jchange);
1577   }
1578 }
1579
1580 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1581   bool c_result = SwigValueInit< bool >() ;
1582   unsigned int jresult = 0 ;
1583
1584   if (!swig_callbackOnAccessibilityActivated) {
1585     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1586   } else {
1587     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1588     c_result = jresult ? true : false;
1589   }
1590   return c_result;
1591 }
1592
1593 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
1594   bool c_result = SwigValueInit< bool >() ;
1595   unsigned int jresult = 0 ;
1596
1597   if (!swig_callbackOnAccessibilityPan) {
1598     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
1599   } else {
1600     jresult = (unsigned int) swig_callbackOnAccessibilityPan((Dali::PanGesture*)&gesture);
1601     c_result = jresult ? true : false;
1602   }
1603   return c_result;
1604 }
1605
1606 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
1607   bool c_result = SwigValueInit< bool >() ;
1608   unsigned int jresult = 0 ;
1609   unsigned int jisIncrease  ;
1610
1611   if (!swig_callbackOnAccessibilityValueChange) {
1612     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
1613   } else {
1614     jisIncrease = isIncrease;
1615     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
1616     c_result = jresult ? true : false;
1617   }
1618   return c_result;
1619 }
1620
1621 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
1622   bool c_result = SwigValueInit< bool >() ;
1623   unsigned int jresult = 0 ;
1624
1625   if (!swig_callbackOnAccessibilityZoom) {
1626     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
1627   } else {
1628     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
1629     c_result = jresult ? true : false;
1630   }
1631   return c_result;
1632 }
1633
1634 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
1635   if (!swig_callbackOnKeyInputFocusGained) {
1636     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
1637     return;
1638   } else {
1639     swig_callbackOnKeyInputFocusGained();
1640   }
1641 }
1642
1643 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
1644   if (!swig_callbackOnKeyInputFocusLost) {
1645     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
1646     return;
1647   } else {
1648     swig_callbackOnKeyInputFocusLost();
1649   }
1650 }
1651
1652
1653 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled)
1654 {
1655   Dali::Actor c_result;
1656   void* jresult = 0;
1657
1658   if(!swig_callbackGetNextKeyboardFocusableActor)
1659   {
1660     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
1661   }
1662   else
1663   {
1664     jresult = (void*)swig_callbackGetNextKeyboardFocusableActor((void*)(&currentFocusedActor), (int)direction, loopEnabled);
1665
1666     if(!jresult)
1667     {
1668       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
1669       return c_result;
1670     }
1671     c_result = *(Dali::Actor*)jresult;
1672   }
1673   return c_result;
1674 }
1675
1676 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor)
1677 {
1678   if(!swig_callbackOnKeyboardFocusChangeCommitted)
1679   {
1680     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
1681     return;
1682   }
1683   else
1684   {
1685     swig_callbackOnKeyboardFocusChangeCommitted((void*)(&commitedFocusableActor));
1686   }
1687 }
1688
1689 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
1690   bool c_result = SwigValueInit< bool >() ;
1691   unsigned int jresult = 0 ;
1692
1693   if (!swig_callbackOnKeyboardEnter) {
1694     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
1695   } else {
1696     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
1697     c_result = jresult ? true : false;
1698   }
1699   return c_result;
1700 }
1701
1702 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
1703   void * jpinch = 0 ;
1704
1705   if (!swig_callbackOnPinch) {
1706     Dali::Toolkit::Internal::Control::OnPinch(pinch);
1707     return;
1708   } else {
1709     jpinch = (Dali::PinchGesture *) &pinch;
1710     swig_callbackOnPinch(jpinch);
1711   }
1712 }
1713
1714 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
1715   void * jpan = 0 ;
1716
1717   if (!swig_callbackOnPan) {
1718     Dali::Toolkit::Internal::Control::OnPan(pan);
1719     return;
1720   } else {
1721     jpan = (Dali::PanGesture *) &pan;
1722     swig_callbackOnPan(jpan);
1723   }
1724 }
1725
1726 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
1727   void * jtap = 0 ;
1728
1729   if (!swig_callbackOnTap) {
1730     Dali::Toolkit::Internal::Control::OnTap(tap);
1731     return;
1732   } else {
1733     jtap = (Dali::TapGesture *) &tap;
1734     swig_callbackOnTap(jtap);
1735   }
1736 }
1737
1738 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
1739   void * jlongPress = 0 ;
1740
1741   if (!swig_callbackOnLongPress) {
1742     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
1743     return;
1744   } else {
1745     jlongPress = (Dali::LongPressGesture *) &longPress;
1746     swig_callbackOnLongPress(jlongPress);
1747   }
1748 }
1749
1750 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1751   void * jslotObserver = 0 ;
1752   void * jcallback = 0 ;
1753
1754   if (!swig_callbackSignalConnected) {
1755     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
1756     return;
1757   } else {
1758     jslotObserver = (void *) slotObserver;
1759     jcallback = (void *) callback;
1760     swig_callbackSignalConnected(jslotObserver, jcallback);
1761   }
1762 }
1763
1764 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1765   void * jslotObserver = 0 ;
1766   void * jcallback = 0 ;
1767
1768   if (!swig_callbackSignalDisconnected) {
1769     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
1770     return;
1771   } else {
1772     jslotObserver = (void *) slotObserver;
1773     jcallback = (void *) callback;
1774     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1775   }
1776 }
1777
1778 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
1779   return Dali::Toolkit::Internal::Control::GetControlExtension();
1780 }
1781
1782 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) {
1783   swig_callbackOnSceneConnection = callbackOnSceneConnection;
1784   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
1785   swig_callbackOnChildAdd = callbackOnChildAdd;
1786   swig_callbackOnChildRemove = callbackOnChildRemove;
1787   swig_callbackOnPropertySet = callbackOnPropertySet;
1788   swig_callbackOnSizeSet = callbackOnSizeSet;
1789   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
1790   swig_callbackOnKeyEvent = callbackOnKeyEvent;
1791   swig_callbackOnRelayout = callbackOnRelayout;
1792   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
1793   swig_callbackGetNaturalSize = callbackGetNaturalSize;
1794   swig_callbackCalculateChildSize = callbackCalculateChildSize;
1795   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
1796   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
1797   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
1798   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
1799   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
1800   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
1801   swig_callbackOnInitialize = callbackOnInitialize;
1802   swig_callbackOnStyleChange = callbackOnStyleChange;
1803   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
1804   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
1805   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
1806   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
1807   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
1808   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
1809   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
1810   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
1811   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
1812   swig_callbackOnPinch = callbackOnPinch;
1813   swig_callbackOnPan = callbackOnPan;
1814   swig_callbackOnTap = callbackOnTap;
1815   swig_callbackOnLongPress = callbackOnLongPress;
1816   swig_callbackSignalConnected = callbackSignalConnected;
1817   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1818 }
1819
1820 void SwigDirector_ViewImpl::swig_init_callbacks() {
1821   swig_callbackOnSceneConnection = 0;
1822   swig_callbackOnSceneDisconnection = 0;
1823   swig_callbackOnChildAdd = 0;
1824   swig_callbackOnChildRemove = 0;
1825   swig_callbackOnPropertySet = 0;
1826   swig_callbackOnSizeSet = 0;
1827   swig_callbackOnSizeAnimation = 0;
1828   swig_callbackOnKeyEvent = 0;
1829   swig_callbackOnRelayout = 0;
1830   swig_callbackOnSetResizePolicy = 0;
1831   swig_callbackGetNaturalSize = 0;
1832   swig_callbackCalculateChildSize = 0;
1833   swig_callbackGetHeightForWidth = 0;
1834   swig_callbackGetWidthForHeight = 0;
1835   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
1836   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
1837   swig_callbackOnCalculateRelayoutSize = 0;
1838   swig_callbackOnLayoutNegotiated = 0;
1839   swig_callbackOnInitialize = 0;
1840   swig_callbackOnStyleChange = 0;
1841   swig_callbackOnAccessibilityActivated = 0;
1842   swig_callbackOnAccessibilityPan = 0;
1843   swig_callbackOnAccessibilityValueChange = 0;
1844   swig_callbackOnAccessibilityZoom = 0;
1845   swig_callbackOnKeyInputFocusGained = 0;
1846   swig_callbackOnKeyInputFocusLost = 0;
1847   swig_callbackGetNextKeyboardFocusableActor = 0;
1848   swig_callbackOnKeyboardFocusChangeCommitted = 0;
1849   swig_callbackOnKeyboardEnter = 0;
1850   swig_callbackOnPinch = 0;
1851   swig_callbackOnPan = 0;
1852   swig_callbackOnTap = 0;
1853   swig_callbackOnLongPress = 0;
1854   swig_callbackSignalConnected = 0;
1855   swig_callbackSignalDisconnected = 0;
1856 }
1857
1858 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
1859   swig_init_callbacks();
1860 }
1861
1862 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
1863
1864 }
1865
1866
1867 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
1868   unsigned int c_result = SwigValueInit< unsigned int >() ;
1869   unsigned int jresult = 0 ;
1870
1871   if (!swig_callbackGetNumberOfItems) {
1872     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
1873   } else {
1874     jresult = (unsigned int) swig_callbackGetNumberOfItems();
1875     c_result = (unsigned int)jresult;
1876   }
1877   return c_result;
1878 }
1879
1880 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
1881   Dali::Actor c_result ;
1882   void * jresult = 0 ;
1883   unsigned int jitemId  ;
1884
1885   if (!swig_callbackNewItem) {
1886     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
1887   } else {
1888     jitemId = itemId;
1889     jresult = (void *) swig_callbackNewItem(jitemId);
1890     if (!jresult) {
1891       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
1892       return c_result;
1893     }
1894     c_result = *(Dali::Actor *)jresult;
1895   }
1896   return c_result;
1897 }
1898
1899 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor)
1900 {
1901   if(!swig_callbackItemReleased)
1902   {
1903     Dali::Toolkit::ItemFactory::ItemReleased(itemId, actor);
1904     return;
1905   }
1906   else
1907   {
1908     swig_callbackItemReleased(itemId, (void*)(&actor));
1909   }
1910 }
1911
1912 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
1913   return Dali::Toolkit::ItemFactory::GetExtension();
1914 }
1915
1916 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
1917   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
1918   swig_callbackNewItem = callbackNewItem;
1919   swig_callbackItemReleased = callbackItemReleased;
1920 }
1921
1922 void SwigDirector_ItemFactory::swig_init_callbacks() {
1923   swig_callbackGetNumberOfItems = 0;
1924   swig_callbackNewItem = 0;
1925   swig_callbackItemReleased = 0;
1926 }
1927
1928 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
1929   swig_init_callbacks();
1930 }
1931
1932 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
1933
1934 }
1935
1936 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction, const std::string& deviceName)
1937 {
1938   Dali::Actor c_result;
1939   void* jresult = 0;
1940
1941   if(!swig_callbackGetNextFocusableActor)
1942   {
1943     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
1944   }
1945   else
1946   {
1947     jresult = (void*)swig_callbackGetNextFocusableActor((void*)(&current), (void*)(&proposed), direction, deviceName.c_str());
1948     if(!jresult)
1949     {
1950       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__);
1951       return c_result;
1952     }
1953     c_result = *(Dali::Actor*)jresult;
1954   }
1955   return c_result;
1956 }
1957
1958 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
1959   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
1960 }
1961
1962 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
1963   swig_callbackGetNextFocusableActor = 0;
1964 }
1965
1966 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
1967   swig_callbackOnUpdate = nullptr;
1968   swig_callbackOnUpdateWithReturn = nullptr;
1969 }
1970
1971 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
1972
1973 }
1974
1975 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
1976   swig_callbackOnUpdate = callbackUpdate;
1977   swig_callbackOnUpdateWithReturn = nullptr;
1978 }
1979
1980 void SwigDirector_FrameCallbackInterface::swig_connect_director_with_return(SWIG_Callback1_t callbackUpdate) {
1981   swig_callbackOnUpdateWithReturn = callbackUpdate;
1982   swig_callbackOnUpdate = nullptr;
1983 }
1984
1985 bool SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
1986   void * jcurrent  ;
1987   bool jresult = false;
1988
1989   if (!swig_callbackOnUpdate && !swig_callbackOnUpdateWithReturn) {
1990     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
1991   } else {
1992     Dali::UpdateProxy* proxy = &updateProxy;
1993     jcurrent = (void *)proxy;
1994
1995     if(swig_callbackOnUpdateWithReturn)
1996     {
1997       jresult = swig_callbackOnUpdateWithReturn(jcurrent, elapsedSeconds);
1998     }
1999     else
2000     {
2001       swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2002     }
2003
2004     if (!jcurrent) {
2005       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2006       return false;
2007     }
2008   }
2009   return jresult;
2010 }
2011
2012
2013
2014 /*******************************************/
2015 /*                 Binding                 */
2016 /*******************************************/
2017
2018 #ifdef __cplusplus
2019 extern "C" {
2020 #endif
2021
2022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2023   void * jresult ;
2024   floatp *result = 0 ;
2025
2026   {
2027     try {
2028       result = (floatp *)new_floatp();
2029     } CALL_CATCH_EXCEPTION(0);
2030   }
2031   jresult = (void *)result;
2032   return jresult;
2033 }
2034
2035
2036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2037   floatp *arg1 = (floatp *) 0 ;
2038
2039   arg1 = (floatp *)jarg1;
2040   {
2041     try {
2042       delete_floatp(arg1);
2043     } CALL_CATCH_EXCEPTION();
2044   }
2045
2046 }
2047
2048
2049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2050   floatp *arg1 = (floatp *) 0 ;
2051   float arg2 ;
2052
2053   arg1 = (floatp *)jarg1;
2054   arg2 = (float)jarg2;
2055   {
2056     try {
2057       floatp_assign(arg1,arg2);
2058     } CALL_CATCH_EXCEPTION();
2059   }
2060
2061 }
2062
2063
2064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2065   float jresult ;
2066   floatp *arg1 = (floatp *) 0 ;
2067   float result;
2068
2069   arg1 = (floatp *)jarg1;
2070   {
2071     try {
2072       result = (float)floatp_value(arg1);
2073     } CALL_CATCH_EXCEPTION(0);
2074   }
2075   jresult = result;
2076   return jresult;
2077 }
2078
2079
2080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2081   void * jresult ;
2082   floatp *arg1 = (floatp *) 0 ;
2083   float *result = 0 ;
2084
2085   arg1 = (floatp *)jarg1;
2086   {
2087     try {
2088       result = (float *)floatp_cast(arg1);
2089     } CALL_CATCH_EXCEPTION(0);
2090   }
2091
2092   jresult = (void *)result;
2093   return jresult;
2094 }
2095
2096
2097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2098   void * jresult ;
2099   float *arg1 = (float *) 0 ;
2100   floatp *result = 0 ;
2101
2102   arg1 = (float *)jarg1;
2103   {
2104     try {
2105       result = (floatp *)floatp_frompointer(arg1);
2106     } CALL_CATCH_EXCEPTION(0);
2107   }
2108
2109   jresult = (void *)result;
2110   return jresult;
2111 }
2112
2113
2114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2115   void * jresult ;
2116   intp *result = 0 ;
2117
2118   {
2119     try {
2120       result = (intp *)new_intp();
2121     } CALL_CATCH_EXCEPTION(0);
2122   }
2123
2124   jresult = (void *)result;
2125   return jresult;
2126 }
2127
2128
2129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2130   intp *arg1 = (intp *) 0 ;
2131
2132   arg1 = (intp *)jarg1;
2133   {
2134     try {
2135       delete_intp(arg1);
2136     } CALL_CATCH_EXCEPTION();
2137   }
2138
2139 }
2140
2141
2142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2143   intp *arg1 = (intp *) 0 ;
2144   int arg2 ;
2145
2146   arg1 = (intp *)jarg1;
2147   arg2 = (int)jarg2;
2148   {
2149     try {
2150       intp_assign(arg1,arg2);
2151     } CALL_CATCH_EXCEPTION();
2152   }
2153
2154 }
2155
2156
2157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2158   int jresult ;
2159   intp *arg1 = (intp *) 0 ;
2160   int result;
2161
2162   arg1 = (intp *)jarg1;
2163   {
2164     try {
2165       result = (int)intp_value(arg1);
2166     } CALL_CATCH_EXCEPTION(0);
2167   }
2168
2169   jresult = result;
2170   return jresult;
2171 }
2172
2173
2174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2175   void * jresult ;
2176   intp *arg1 = (intp *) 0 ;
2177   int *result = 0 ;
2178
2179   arg1 = (intp *)jarg1;
2180   {
2181     try {
2182       result = (int *)intp_cast(arg1);
2183     } CALL_CATCH_EXCEPTION(0);
2184   }
2185
2186   jresult = (void *)result;
2187   return jresult;
2188 }
2189
2190
2191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2192   void * jresult ;
2193   int *arg1 = (int *) 0 ;
2194   intp *result = 0 ;
2195
2196   arg1 = (int *)jarg1;
2197   {
2198     try {
2199       result = (intp *)intp_frompointer(arg1);
2200     } CALL_CATCH_EXCEPTION(0);
2201   }
2202
2203   jresult = (void *)result;
2204   return jresult;
2205 }
2206
2207
2208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2209   void * jresult ;
2210   doublep *result = 0 ;
2211
2212   {
2213     try {
2214       result = (doublep *)new_doublep();
2215     } CALL_CATCH_EXCEPTION(0);
2216   }
2217
2218   jresult = (void *)result;
2219   return jresult;
2220 }
2221
2222
2223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2224   doublep *arg1 = (doublep *) 0 ;
2225
2226   arg1 = (doublep *)jarg1;
2227   {
2228     try {
2229       delete_doublep(arg1);
2230     } CALL_CATCH_EXCEPTION();
2231   }
2232
2233 }
2234
2235
2236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2237   doublep *arg1 = (doublep *) 0 ;
2238   double arg2 ;
2239
2240   arg1 = (doublep *)jarg1;
2241   arg2 = (double)jarg2;
2242   {
2243     try {
2244       doublep_assign(arg1,arg2);
2245     } CALL_CATCH_EXCEPTION();
2246   }
2247
2248 }
2249
2250
2251 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2252   double jresult ;
2253   doublep *arg1 = (doublep *) 0 ;
2254   double result;
2255
2256   arg1 = (doublep *)jarg1;
2257   {
2258     try {
2259       result = (double)doublep_value(arg1);
2260     } CALL_CATCH_EXCEPTION(0);
2261   }
2262
2263   jresult = result;
2264   return jresult;
2265 }
2266
2267
2268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2269   void * jresult ;
2270   doublep *arg1 = (doublep *) 0 ;
2271   double *result = 0 ;
2272
2273   arg1 = (doublep *)jarg1;
2274   {
2275     try {
2276       result = (double *)doublep_cast(arg1);
2277     } CALL_CATCH_EXCEPTION(0);
2278   }
2279
2280   jresult = (void *)result;
2281   return jresult;
2282 }
2283
2284
2285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2286   void * jresult ;
2287   double *arg1 = (double *) 0 ;
2288   doublep *result = 0 ;
2289
2290   arg1 = (double *)jarg1;
2291   {
2292     try {
2293       result = (doublep *)doublep_frompointer(arg1);
2294     } CALL_CATCH_EXCEPTION(0);
2295   }
2296
2297   jresult = (void *)result;
2298   return jresult;
2299 }
2300
2301
2302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2303   void * jresult ;
2304   uintp *result = 0 ;
2305
2306   {
2307     try {
2308       result = (uintp *)new_uintp();
2309     } CALL_CATCH_EXCEPTION(0);
2310   }
2311
2312   jresult = (void *)result;
2313   return jresult;
2314 }
2315
2316
2317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2318   uintp *arg1 = (uintp *) 0 ;
2319
2320   arg1 = (uintp *)jarg1;
2321   {
2322     try {
2323       delete_uintp(arg1);
2324     } CALL_CATCH_EXCEPTION();
2325   }
2326
2327 }
2328
2329
2330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2331   uintp *arg1 = (uintp *) 0 ;
2332   unsigned int arg2 ;
2333
2334   arg1 = (uintp *)jarg1;
2335   arg2 = (unsigned int)jarg2;
2336   {
2337     try {
2338       uintp_assign(arg1,arg2);
2339     } CALL_CATCH_EXCEPTION();
2340   }
2341
2342 }
2343
2344
2345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2346   unsigned int jresult ;
2347   uintp *arg1 = (uintp *) 0 ;
2348   unsigned int result;
2349
2350   arg1 = (uintp *)jarg1;
2351   {
2352     try {
2353       result = (unsigned int)uintp_value(arg1);
2354     } CALL_CATCH_EXCEPTION(0);
2355   }
2356
2357   jresult = result;
2358   return jresult;
2359 }
2360
2361
2362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2363   void * jresult ;
2364   uintp *arg1 = (uintp *) 0 ;
2365   unsigned int *result = 0 ;
2366
2367   arg1 = (uintp *)jarg1;
2368   {
2369     try {
2370       result = (unsigned int *)uintp_cast(arg1);
2371     } CALL_CATCH_EXCEPTION(0);
2372   }
2373
2374   jresult = (void *)result;
2375   return jresult;
2376 }
2377
2378
2379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2380   void * jresult ;
2381   unsigned int *arg1 = (unsigned int *) 0 ;
2382   uintp *result = 0 ;
2383
2384   arg1 = (unsigned int *)jarg1;
2385   {
2386     try {
2387       result = (uintp *)uintp_frompointer(arg1);
2388     } CALL_CATCH_EXCEPTION(0);
2389   }
2390
2391   jresult = (void *)result;
2392   return jresult;
2393 }
2394
2395
2396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2397   void * jresult ;
2398   ushortp *result = 0 ;
2399
2400   {
2401     try {
2402       result = (ushortp *)new_ushortp();
2403     } CALL_CATCH_EXCEPTION(0);
2404   }
2405
2406   jresult = (void *)result;
2407   return jresult;
2408 }
2409
2410
2411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2412   ushortp *arg1 = (ushortp *) 0 ;
2413
2414   arg1 = (ushortp *)jarg1;
2415   {
2416     try {
2417       delete_ushortp(arg1);
2418     } CALL_CATCH_EXCEPTION();
2419   }
2420
2421 }
2422
2423
2424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2425   ushortp *arg1 = (ushortp *) 0 ;
2426   unsigned short arg2 ;
2427
2428   arg1 = (ushortp *)jarg1;
2429   arg2 = (unsigned short)jarg2;
2430   {
2431     try {
2432       ushortp_assign(arg1,arg2);
2433     } CALL_CATCH_EXCEPTION();
2434   }
2435
2436 }
2437
2438
2439 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2440   unsigned short jresult ;
2441   ushortp *arg1 = (ushortp *) 0 ;
2442   unsigned short result;
2443
2444   arg1 = (ushortp *)jarg1;
2445   {
2446     try {
2447       result = (unsigned short)ushortp_value(arg1);
2448     } CALL_CATCH_EXCEPTION(0);
2449   }
2450
2451   jresult = result;
2452   return jresult;
2453 }
2454
2455
2456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2457   void * jresult ;
2458   ushortp *arg1 = (ushortp *) 0 ;
2459   unsigned short *result = 0 ;
2460
2461   arg1 = (ushortp *)jarg1;
2462   {
2463     try {
2464       result = (unsigned short *)ushortp_cast(arg1);
2465     } CALL_CATCH_EXCEPTION(0);
2466   }
2467
2468   jresult = (void *)result;
2469   return jresult;
2470 }
2471
2472
2473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2474   void * jresult ;
2475   unsigned short *arg1 = (unsigned short *) 0 ;
2476   ushortp *result = 0 ;
2477
2478   arg1 = (unsigned short *)jarg1;
2479   {
2480     try {
2481       result = (ushortp *)ushortp_frompointer(arg1);
2482     } CALL_CATCH_EXCEPTION(0);
2483   }
2484
2485   jresult = (void *)result;
2486   return jresult;
2487 }
2488
2489
2490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2491   unsigned int jresult ;
2492   int arg1 ;
2493   unsigned int result;
2494
2495   arg1 = (int)jarg1;
2496   {
2497     try {
2498       result = (unsigned int)int_to_uint(arg1);
2499     } CALL_CATCH_EXCEPTION(0);
2500   }
2501
2502   jresult = result;
2503   return jresult;
2504 }
2505
2506
2507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
2508   char *arg1 = (char *) 0 ;
2509   char *arg2 = (char *) 0 ;
2510
2511   arg1 = (char *)jarg1;
2512   arg2 = (char *)jarg2;
2513   {
2514     try {
2515       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
2516     } CALL_CATCH_EXCEPTION();
2517   }
2518
2519 }
2520
2521
2522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
2523   void * jresult ;
2524   char *arg1 = (char *) 0 ;
2525   char *arg2 = (char *) 0 ;
2526   Dali::DaliException *result = 0 ;
2527
2528   arg1 = (char *)jarg1;
2529   arg2 = (char *)jarg2;
2530   {
2531     try {
2532       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
2533     } CALL_CATCH_EXCEPTION(0);
2534   }
2535
2536   jresult = (void *)result;
2537   return jresult;
2538 }
2539
2540
2541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
2542   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2543   std::string arg2 = std::string(jarg2);
2544
2545   arg1 = (Dali::DaliException *)jarg1;
2546   {
2547     if (!arg2.empty()) {
2548       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
2549     } else {
2550       arg1->location = 0;
2551     }
2552   }
2553 }
2554
2555 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
2556   char * jresult ;
2557   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2558   char *result = 0 ;
2559
2560   arg1 = (Dali::DaliException *)jarg1;
2561   result = (char *) ((arg1)->location);
2562   jresult = SWIG_csharp_string_callback((const char *)result);
2563   return jresult;
2564 }
2565
2566
2567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
2568   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2569   std::string arg2 = std::string(jarg2);
2570
2571   arg1 = (Dali::DaliException *)jarg1;
2572   {
2573     if (!arg2.empty()) {
2574       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
2575     } else {
2576       arg1->condition = 0;
2577     }
2578   }
2579 }
2580
2581
2582 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
2583   char * jresult ;
2584   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2585   char *result = 0 ;
2586
2587   arg1 = (Dali::DaliException *)jarg1;
2588   result = (char *) ((arg1)->condition);
2589   jresult = SWIG_csharp_string_callback((const char *)result);
2590   return jresult;
2591 }
2592
2593
2594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
2595   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
2596
2597   arg1 = (Dali::DaliException *)jarg1;
2598   {
2599     try {
2600       delete arg1;
2601     } CALL_CATCH_EXCEPTION();
2602   }
2603
2604 }
2605
2606
2607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
2608   void * jresult ;
2609   Dali::Uint16Pair *result = 0 ;
2610
2611   {
2612     try {
2613       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
2614     } CALL_CATCH_EXCEPTION(0);
2615   }
2616
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
2623   void * jresult ;
2624   uint32_t arg1 ;
2625   uint32_t arg2 ;
2626   Dali::Uint16Pair *result = 0 ;
2627
2628   arg1 = (uint32_t)jarg1;
2629   arg2 = (uint32_t)jarg2;
2630   {
2631     try {
2632       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
2633     } CALL_CATCH_EXCEPTION(0);
2634   }
2635
2636   jresult = (void *)result;
2637   return jresult;
2638 }
2639
2640
2641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
2642   void * jresult ;
2643   Dali::Uint16Pair *arg1 = 0 ;
2644   Dali::Uint16Pair *result = 0 ;
2645
2646   arg1 = (Dali::Uint16Pair *)jarg1;
2647   if (!arg1) {
2648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2649     return 0;
2650   }
2651   {
2652     try {
2653       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
2654     } CALL_CATCH_EXCEPTION(0);
2655   }
2656
2657   jresult = (void *)result;
2658   return jresult;
2659 }
2660
2661
2662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
2663   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2664   uint16_t arg2 ;
2665
2666   arg1 = (Dali::Uint16Pair *)jarg1;
2667   arg2 = (uint16_t)jarg2;
2668   {
2669     try {
2670       (arg1)->SetWidth(arg2);
2671     } CALL_CATCH_EXCEPTION();
2672   }
2673
2674 }
2675
2676
2677 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
2678   unsigned short jresult ;
2679   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2680   uint16_t result;
2681
2682   arg1 = (Dali::Uint16Pair *)jarg1;
2683   {
2684     try {
2685       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
2686     } CALL_CATCH_EXCEPTION(0);
2687   }
2688
2689   jresult = result;
2690   return jresult;
2691 }
2692
2693
2694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
2695   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2696   uint16_t arg2 ;
2697
2698   arg1 = (Dali::Uint16Pair *)jarg1;
2699   arg2 = (uint16_t)jarg2;
2700   {
2701     try {
2702       (arg1)->SetHeight(arg2);
2703     } CALL_CATCH_EXCEPTION();
2704   }
2705
2706 }
2707
2708
2709 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
2710   unsigned short jresult ;
2711   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2712   uint16_t result;
2713
2714   arg1 = (Dali::Uint16Pair *)jarg1;
2715   {
2716     try {
2717       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
2718     } CALL_CATCH_EXCEPTION(0);
2719   }
2720
2721   jresult = result;
2722   return jresult;
2723 }
2724
2725
2726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
2727   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2728   uint16_t arg2 ;
2729
2730   arg1 = (Dali::Uint16Pair *)jarg1;
2731   arg2 = (uint16_t)jarg2;
2732   {
2733     try {
2734       (arg1)->SetX(arg2);
2735     } CALL_CATCH_EXCEPTION();
2736   }
2737
2738 }
2739
2740
2741 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
2742   unsigned short jresult ;
2743   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2744   uint16_t result;
2745
2746   arg1 = (Dali::Uint16Pair *)jarg1;
2747   {
2748     try {
2749       result = ((Dali::Uint16Pair const *)arg1)->GetX();
2750     } CALL_CATCH_EXCEPTION(0);
2751   }
2752
2753   jresult = result;
2754   return jresult;
2755 }
2756
2757
2758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
2759   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2760   uint16_t arg2 ;
2761
2762   arg1 = (Dali::Uint16Pair *)jarg1;
2763   arg2 = (uint16_t)jarg2;
2764   {
2765     try {
2766       (arg1)->SetY(arg2);
2767     } CALL_CATCH_EXCEPTION();
2768   }
2769
2770 }
2771
2772
2773 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
2774   unsigned short jresult ;
2775   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2776   uint16_t result;
2777
2778   arg1 = (Dali::Uint16Pair *)jarg1;
2779   {
2780     try {
2781       result = ((Dali::Uint16Pair const *)arg1)->GetY();
2782     } CALL_CATCH_EXCEPTION(0);
2783   }
2784
2785   jresult = result;
2786   return jresult;
2787 }
2788
2789
2790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
2791   void * jresult ;
2792   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2793   Dali::Uint16Pair *arg2 = 0 ;
2794   Dali::Uint16Pair *result = 0 ;
2795
2796   arg1 = (Dali::Uint16Pair *)jarg1;
2797   arg2 = (Dali::Uint16Pair *)jarg2;
2798   if (!arg2) {
2799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2800     return 0;
2801   }
2802   {
2803     try {
2804       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
2805     } CALL_CATCH_EXCEPTION(0);
2806   }
2807
2808   jresult = (void *)result;
2809   return jresult;
2810 }
2811
2812
2813 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
2814   bool jresult ;
2815   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2816   Dali::Uint16Pair *arg2 = 0 ;
2817   bool result;
2818
2819   arg1 = (Dali::Uint16Pair *)jarg1;
2820   arg2 = (Dali::Uint16Pair *)jarg2;
2821   if (!arg2) {
2822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2823     return 0;
2824   }
2825   {
2826     try {
2827       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
2828     } CALL_CATCH_EXCEPTION(0);
2829   }
2830
2831   jresult = result;
2832   return jresult;
2833 }
2834
2835
2836 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
2837   bool jresult ;
2838   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2839   Dali::Uint16Pair *arg2 = 0 ;
2840   bool result;
2841
2842   arg1 = (Dali::Uint16Pair *)jarg1;
2843   arg2 = (Dali::Uint16Pair *)jarg2;
2844   if (!arg2) {
2845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2846     return 0;
2847   }
2848   {
2849     try {
2850       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
2851     } CALL_CATCH_EXCEPTION(0);
2852   }
2853
2854   jresult = result;
2855   return jresult;
2856 }
2857
2858
2859 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
2860   bool jresult ;
2861   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2862   Dali::Uint16Pair *arg2 = 0 ;
2863   bool result;
2864
2865   arg1 = (Dali::Uint16Pair *)jarg1;
2866   arg2 = (Dali::Uint16Pair *)jarg2;
2867   if (!arg2) {
2868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2869     return 0;
2870   }
2871   {
2872     try {
2873       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
2874     } CALL_CATCH_EXCEPTION(0);
2875   }
2876
2877   jresult = result;
2878   return jresult;
2879 }
2880
2881
2882 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
2883   bool jresult ;
2884   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2885   Dali::Uint16Pair *arg2 = 0 ;
2886   bool result;
2887
2888   arg1 = (Dali::Uint16Pair *)jarg1;
2889   arg2 = (Dali::Uint16Pair *)jarg2;
2890   if (!arg2) {
2891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
2892     return 0;
2893   }
2894   {
2895     try {
2896       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
2897     } CALL_CATCH_EXCEPTION(0);
2898   }
2899
2900   jresult = result;
2901   return jresult;
2902 }
2903
2904
2905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
2906   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
2907
2908   arg1 = (Dali::Uint16Pair *)jarg1;
2909   {
2910     try {
2911       delete arg1;
2912     } CALL_CATCH_EXCEPTION();
2913   }
2914
2915 }
2916
2917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_0() {
2918   void * jresult ;
2919   Dali::Int32Pair *result = 0 ;
2920
2921   {
2922     try {
2923       result = (Dali::Int32Pair *)new Dali::Int32Pair();
2924     } CALL_CATCH_EXCEPTION(0);
2925   }
2926
2927   jresult = (void *)result;
2928   return jresult;
2929 }
2930
2931
2932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Int32Pair__SWIG_1(int32_t x, int32_t y) {
2933   void * jresult ;
2934   Dali::Int32Pair *result = 0 ;
2935
2936   {
2937     try {
2938       result = (Dali::Int32Pair *)new Dali::Int32Pair(x,y);
2939     } CALL_CATCH_EXCEPTION(0);
2940   }
2941
2942   jresult = (void *)result;
2943   return jresult;
2944 }
2945
2946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetX(void * int32Pair, int32_t x) {
2947   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2948
2949   {
2950     try {
2951       (pInt32Pair)->SetX(x);
2952     } CALL_CATCH_EXCEPTION();
2953   }
2954 }
2955
2956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetX(void * int32Pair) {
2957   int result ;
2958   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair);
2959
2960   {
2961     try {
2962       result = ((Dali::Int32Pair const *)pInt32Pair)->GetX();
2963     } CALL_CATCH_EXCEPTION(0);
2964   }
2965
2966   return result;
2967 }
2968
2969
2970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Int32Pair_SetY(void * int32Pair, int32_t y) {
2971   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2972
2973   {
2974     try {
2975       (pInt32Pair)->SetY(y);
2976     } CALL_CATCH_EXCEPTION();
2977   }
2978
2979 }
2980
2981
2982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Int32Pair_GetY(void * int32Pair) {
2983   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2984   int result;
2985
2986   {
2987     try {
2988       result = ((Dali::Int32Pair const *)pInt32Pair)->GetY();
2989     } CALL_CATCH_EXCEPTION(0);
2990   }
2991
2992   return result;
2993 }
2994
2995
2996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Int32Pair(void * int32Pair) {
2997   Dali::Int32Pair *pInt32Pair = (Dali::Int32Pair *) (int32Pair) ;
2998
2999   {
3000     try {
3001       delete pInt32Pair;
3002     } CALL_CATCH_EXCEPTION();
3003   }
3004
3005 }
3006
3007
3008
3009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
3010   void * jresult ;
3011   Dali::Degree *result = 0 ;
3012
3013   {
3014     try {
3015       result = (Dali::Degree *)new Dali::Degree();
3016     } CALL_CATCH_EXCEPTION(0);
3017   }
3018
3019   jresult = (void *)result;
3020   return jresult;
3021 }
3022
3023
3024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
3025   void * jresult ;
3026   float arg1 ;
3027   Dali::Degree *result = 0 ;
3028
3029   arg1 = (float)jarg1;
3030   {
3031     try {
3032       result = (Dali::Degree *)new Dali::Degree(arg1);
3033     } CALL_CATCH_EXCEPTION(0);
3034   }
3035
3036   jresult = (void *)result;
3037   return jresult;
3038 }
3039
3040
3041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
3042   void * jresult ;
3043   Dali::Radian arg1 ;
3044   Dali::Radian *argp1 ;
3045   Dali::Degree *result = 0 ;
3046
3047   argp1 = (Dali::Radian *)jarg1;
3048   if (!argp1) {
3049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3050     return 0;
3051   }
3052   arg1 = *argp1;
3053   {
3054     try {
3055       result = (Dali::Degree *)new Dali::Degree(arg1);
3056     } CALL_CATCH_EXCEPTION(0);
3057   }
3058
3059   jresult = (void *)result;
3060   return jresult;
3061 }
3062
3063
3064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
3065   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
3066   float arg2 ;
3067
3068   arg1 = (Dali::Degree *)jarg1;
3069   arg2 = (float)jarg2;
3070   if (arg1) (arg1)->degree = arg2;
3071 }
3072
3073
3074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
3075   float jresult ;
3076   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
3077   float result;
3078
3079   arg1 = (Dali::Degree *)jarg1;
3080   result = (float) ((arg1)->degree);
3081   jresult = result;
3082   return jresult;
3083 }
3084
3085
3086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
3087   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
3088
3089   arg1 = (Dali::Degree *)jarg1;
3090   {
3091     try {
3092       delete arg1;
3093     } CALL_CATCH_EXCEPTION();
3094   }
3095
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
3100   void * jresult ;
3101   Dali::Radian *result = 0 ;
3102
3103   result = (Dali::Radian *)&Dali::ANGLE_360;
3104   jresult = (void *)result;
3105   return jresult;
3106 }
3107
3108
3109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
3110   void * jresult ;
3111   Dali::Radian *result = 0 ;
3112
3113   result = (Dali::Radian *)&Dali::ANGLE_315;
3114   jresult = (void *)result;
3115   return jresult;
3116 }
3117
3118
3119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
3120   void * jresult ;
3121   Dali::Radian *result = 0 ;
3122
3123   result = (Dali::Radian *)&Dali::ANGLE_270;
3124   jresult = (void *)result;
3125   return jresult;
3126 }
3127
3128
3129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
3130   void * jresult ;
3131   Dali::Radian *result = 0 ;
3132
3133   result = (Dali::Radian *)&Dali::ANGLE_225;
3134   jresult = (void *)result;
3135   return jresult;
3136 }
3137
3138
3139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
3140   void * jresult ;
3141   Dali::Radian *result = 0 ;
3142
3143   result = (Dali::Radian *)&Dali::ANGLE_180;
3144   jresult = (void *)result;
3145   return jresult;
3146 }
3147
3148
3149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
3150   void * jresult ;
3151   Dali::Radian *result = 0 ;
3152
3153   result = (Dali::Radian *)&Dali::ANGLE_135;
3154   jresult = (void *)result;
3155   return jresult;
3156 }
3157
3158
3159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
3160   void * jresult ;
3161   Dali::Radian *result = 0 ;
3162
3163   result = (Dali::Radian *)&Dali::ANGLE_120;
3164   jresult = (void *)result;
3165   return jresult;
3166 }
3167
3168
3169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
3170   void * jresult ;
3171   Dali::Radian *result = 0 ;
3172
3173   result = (Dali::Radian *)&Dali::ANGLE_90;
3174   jresult = (void *)result;
3175   return jresult;
3176 }
3177
3178
3179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
3180   void * jresult ;
3181   Dali::Radian *result = 0 ;
3182
3183   result = (Dali::Radian *)&Dali::ANGLE_60;
3184   jresult = (void *)result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
3190   void * jresult ;
3191   Dali::Radian *result = 0 ;
3192
3193   result = (Dali::Radian *)&Dali::ANGLE_45;
3194   jresult = (void *)result;
3195   return jresult;
3196 }
3197
3198
3199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
3200   void * jresult ;
3201   Dali::Radian *result = 0 ;
3202
3203   result = (Dali::Radian *)&Dali::ANGLE_30;
3204   jresult = (void *)result;
3205   return jresult;
3206 }
3207
3208
3209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
3210   void * jresult ;
3211   Dali::Radian *result = 0 ;
3212
3213   result = (Dali::Radian *)&Dali::ANGLE_0;
3214   jresult = (void *)result;
3215   return jresult;
3216 }
3217
3218
3219 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
3220   bool jresult ;
3221   Dali::Degree *arg1 = 0 ;
3222   Dali::Degree *arg2 = 0 ;
3223   bool result;
3224
3225   arg1 = (Dali::Degree *)jarg1;
3226   if (!arg1) {
3227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3228     return 0;
3229   }
3230   arg2 = (Dali::Degree *)jarg2;
3231   if (!arg2) {
3232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3233     return 0;
3234   }
3235   {
3236     try {
3237       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
3238     } CALL_CATCH_EXCEPTION(0);
3239   }
3240
3241   jresult = result;
3242   return jresult;
3243 }
3244
3245
3246 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
3247   bool jresult ;
3248   Dali::Degree *arg1 = 0 ;
3249   Dali::Degree *arg2 = 0 ;
3250   bool result;
3251
3252   arg1 = (Dali::Degree *)jarg1;
3253   if (!arg1) {
3254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3255     return 0;
3256   }
3257   arg2 = (Dali::Degree *)jarg2;
3258   if (!arg2) {
3259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
3260     return 0;
3261   }
3262   {
3263     try {
3264       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
3265     } CALL_CATCH_EXCEPTION(0);
3266   }
3267
3268   jresult = result;
3269   return jresult;
3270 }
3271
3272
3273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
3274   void * jresult ;
3275   Dali::Degree arg1 ;
3276   float arg2 ;
3277   float arg3 ;
3278   Dali::Degree *argp1 ;
3279   Dali::Degree result;
3280
3281   argp1 = (Dali::Degree *)jarg1;
3282   if (!argp1) {
3283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3284     return 0;
3285   }
3286   arg1 = *argp1;
3287   arg2 = (float)jarg2;
3288   arg3 = (float)jarg3;
3289   {
3290     try {
3291       result = Dali::Clamp(arg1,arg2,arg3);
3292     } CALL_CATCH_EXCEPTION(0);
3293   }
3294
3295   jresult = new Dali::Degree((const Dali::Degree &)result);
3296   return jresult;
3297 }
3298
3299
3300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
3301   void * jresult ;
3302   Dali::Radian *result = 0 ;
3303
3304   {
3305     try {
3306       result = (Dali::Radian *)new Dali::Radian();
3307     } CALL_CATCH_EXCEPTION(0);
3308   }
3309
3310   jresult = (void *)result;
3311   return jresult;
3312 }
3313
3314
3315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
3316   void * jresult ;
3317   float arg1 ;
3318   Dali::Radian *result = 0 ;
3319
3320   arg1 = (float)jarg1;
3321   {
3322     try {
3323       result = (Dali::Radian *)new Dali::Radian(arg1);
3324     } CALL_CATCH_EXCEPTION(0);
3325   }
3326
3327   jresult = (void *)result;
3328   return jresult;
3329 }
3330
3331
3332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
3333   void * jresult ;
3334   Dali::Degree arg1 ;
3335   Dali::Degree *argp1 ;
3336   Dali::Radian *result = 0 ;
3337
3338   argp1 = (Dali::Degree *)jarg1;
3339   if (!argp1) {
3340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3341     return 0;
3342   }
3343   arg1 = *argp1;
3344   {
3345     try {
3346       result = (Dali::Radian *)new Dali::Radian(arg1);
3347     } CALL_CATCH_EXCEPTION(0);
3348   }
3349
3350   jresult = (void *)result;
3351   return jresult;
3352 }
3353
3354
3355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
3356   void * jresult ;
3357   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3358   float arg2 ;
3359   Dali::Radian *result = 0 ;
3360
3361   arg1 = (Dali::Radian *)jarg1;
3362   arg2 = (float)jarg2;
3363   {
3364     try {
3365       result = (Dali::Radian *) &(arg1)->operator =(arg2);
3366     } CALL_CATCH_EXCEPTION(0);
3367   }
3368
3369   jresult = (void *)result;
3370   return jresult;
3371 }
3372
3373
3374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
3375   void * jresult ;
3376   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3377   Dali::Degree arg2 ;
3378   Dali::Degree *argp2 ;
3379   Dali::Radian *result = 0 ;
3380
3381   arg1 = (Dali::Radian *)jarg1;
3382   argp2 = (Dali::Degree *)jarg2;
3383   if (!argp2) {
3384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3385     return 0;
3386   }
3387   arg2 = *argp2;
3388   {
3389     try {
3390       result = (Dali::Radian *) &(arg1)->operator =(arg2);
3391     } CALL_CATCH_EXCEPTION(0);
3392   }
3393
3394   jresult = (void *)result;
3395   return jresult;
3396 }
3397
3398
3399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
3400   float jresult ;
3401   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3402   float result;
3403
3404   arg1 = (Dali::Radian *)jarg1;
3405   {
3406     try {
3407       result = (float)((Dali::Radian const *)arg1)->operator float();
3408     } CALL_CATCH_EXCEPTION(0);
3409   }
3410
3411   jresult = result;
3412   return jresult;
3413 }
3414
3415
3416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
3417   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3418   float arg2 ;
3419
3420   arg1 = (Dali::Radian *)jarg1;
3421   arg2 = (float)jarg2;
3422   if (arg1) (arg1)->radian = arg2;
3423 }
3424
3425
3426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
3427   float jresult ;
3428   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3429   float result;
3430
3431   arg1 = (Dali::Radian *)jarg1;
3432   result = (float) ((arg1)->radian);
3433   jresult = result;
3434   return jresult;
3435 }
3436
3437
3438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
3439   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
3440
3441   arg1 = (Dali::Radian *)jarg1;
3442   {
3443     try {
3444       delete arg1;
3445     } CALL_CATCH_EXCEPTION();
3446   }
3447
3448 }
3449
3450
3451 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
3452   bool jresult ;
3453   Dali::Radian arg1 ;
3454   Dali::Radian arg2 ;
3455   Dali::Radian *argp1 ;
3456   Dali::Radian *argp2 ;
3457   bool result;
3458
3459   argp1 = (Dali::Radian *)jarg1;
3460   if (!argp1) {
3461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3462     return 0;
3463   }
3464   arg1 = *argp1;
3465   argp2 = (Dali::Radian *)jarg2;
3466   if (!argp2) {
3467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3468     return 0;
3469   }
3470   arg2 = *argp2;
3471   {
3472     try {
3473       result = (bool)Dali::operator ==(arg1,arg2);
3474     } CALL_CATCH_EXCEPTION(0);
3475   }
3476
3477   jresult = result;
3478   return jresult;
3479 }
3480
3481
3482 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
3483   bool jresult ;
3484   Dali::Radian arg1 ;
3485   Dali::Radian arg2 ;
3486   Dali::Radian *argp1 ;
3487   Dali::Radian *argp2 ;
3488   bool result;
3489
3490   argp1 = (Dali::Radian *)jarg1;
3491   if (!argp1) {
3492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3493     return 0;
3494   }
3495   arg1 = *argp1;
3496   argp2 = (Dali::Radian *)jarg2;
3497   if (!argp2) {
3498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3499     return 0;
3500   }
3501   arg2 = *argp2;
3502   {
3503     try {
3504       result = (bool)Dali::operator !=(arg1,arg2);
3505     } CALL_CATCH_EXCEPTION(0);
3506   }
3507
3508   jresult = result;
3509   return jresult;
3510 }
3511
3512
3513 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
3514   bool jresult ;
3515   Dali::Radian arg1 ;
3516   Dali::Degree arg2 ;
3517   Dali::Radian *argp1 ;
3518   Dali::Degree *argp2 ;
3519   bool result;
3520
3521   argp1 = (Dali::Radian *)jarg1;
3522   if (!argp1) {
3523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3524     return 0;
3525   }
3526   arg1 = *argp1;
3527   argp2 = (Dali::Degree *)jarg2;
3528   if (!argp2) {
3529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3530     return 0;
3531   }
3532   arg2 = *argp2;
3533   {
3534     try {
3535       result = (bool)Dali::operator ==(arg1,arg2);
3536     } CALL_CATCH_EXCEPTION(0);
3537   }
3538
3539   jresult = result;
3540   return jresult;
3541 }
3542
3543
3544 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
3545   bool jresult ;
3546   Dali::Radian arg1 ;
3547   Dali::Degree arg2 ;
3548   Dali::Radian *argp1 ;
3549   Dali::Degree *argp2 ;
3550   bool result;
3551
3552   argp1 = (Dali::Radian *)jarg1;
3553   if (!argp1) {
3554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3555     return 0;
3556   }
3557   arg1 = *argp1;
3558   argp2 = (Dali::Degree *)jarg2;
3559   if (!argp2) {
3560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3561     return 0;
3562   }
3563   arg2 = *argp2;
3564   {
3565     try {
3566       result = (bool)Dali::operator !=(arg1,arg2);
3567     } CALL_CATCH_EXCEPTION(0);
3568   }
3569
3570   jresult = result;
3571   return jresult;
3572 }
3573
3574
3575 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
3576   bool jresult ;
3577   Dali::Degree arg1 ;
3578   Dali::Radian arg2 ;
3579   Dali::Degree *argp1 ;
3580   Dali::Radian *argp2 ;
3581   bool result;
3582
3583   argp1 = (Dali::Degree *)jarg1;
3584   if (!argp1) {
3585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3586     return 0;
3587   }
3588   arg1 = *argp1;
3589   argp2 = (Dali::Radian *)jarg2;
3590   if (!argp2) {
3591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3592     return 0;
3593   }
3594   arg2 = *argp2;
3595   {
3596     try {
3597       result = (bool)Dali::operator ==(arg1,arg2);
3598     } CALL_CATCH_EXCEPTION(0);
3599   }
3600
3601   jresult = result;
3602   return jresult;
3603 }
3604
3605
3606 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
3607   bool jresult ;
3608   Dali::Degree arg1 ;
3609   Dali::Radian arg2 ;
3610   Dali::Degree *argp1 ;
3611   Dali::Radian *argp2 ;
3612   bool result;
3613
3614   argp1 = (Dali::Degree *)jarg1;
3615   if (!argp1) {
3616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3617     return 0;
3618   }
3619   arg1 = *argp1;
3620   argp2 = (Dali::Radian *)jarg2;
3621   if (!argp2) {
3622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3623     return 0;
3624   }
3625   arg2 = *argp2;
3626   {
3627     try {
3628       result = (bool)Dali::operator !=(arg1,arg2);
3629     } CALL_CATCH_EXCEPTION(0);
3630   }
3631
3632   jresult = result;
3633   return jresult;
3634 }
3635
3636
3637 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
3638   bool jresult ;
3639   Dali::Radian arg1 ;
3640   Dali::Radian arg2 ;
3641   Dali::Radian *argp1 ;
3642   Dali::Radian *argp2 ;
3643   bool result;
3644
3645   argp1 = (Dali::Radian *)jarg1;
3646   if (!argp1) {
3647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3648     return 0;
3649   }
3650   arg1 = *argp1;
3651   argp2 = (Dali::Radian *)jarg2;
3652   if (!argp2) {
3653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3654     return 0;
3655   }
3656   arg2 = *argp2;
3657   {
3658     try {
3659       result = (bool)Dali::operator >(arg1,arg2);
3660     } CALL_CATCH_EXCEPTION(0);
3661   }
3662
3663   jresult = result;
3664   return jresult;
3665 }
3666
3667
3668 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
3669   bool jresult ;
3670   Dali::Radian arg1 ;
3671   Dali::Degree arg2 ;
3672   Dali::Radian *argp1 ;
3673   Dali::Degree *argp2 ;
3674   bool result;
3675
3676   argp1 = (Dali::Radian *)jarg1;
3677   if (!argp1) {
3678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3679     return 0;
3680   }
3681   arg1 = *argp1;
3682   argp2 = (Dali::Degree *)jarg2;
3683   if (!argp2) {
3684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3685     return 0;
3686   }
3687   arg2 = *argp2;
3688   {
3689     try {
3690       result = (bool)Dali::operator >(arg1,arg2);
3691     } CALL_CATCH_EXCEPTION(0);
3692   }
3693
3694   jresult = result;
3695   return jresult;
3696 }
3697
3698
3699 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
3700   bool jresult ;
3701   Dali::Degree arg1 ;
3702   Dali::Radian arg2 ;
3703   Dali::Degree *argp1 ;
3704   Dali::Radian *argp2 ;
3705   bool result;
3706
3707   argp1 = (Dali::Degree *)jarg1;
3708   if (!argp1) {
3709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3710     return 0;
3711   }
3712   arg1 = *argp1;
3713   argp2 = (Dali::Radian *)jarg2;
3714   if (!argp2) {
3715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3716     return 0;
3717   }
3718   arg2 = *argp2;
3719   {
3720     try {
3721       result = (bool)Dali::operator >(arg1,arg2);
3722     } CALL_CATCH_EXCEPTION(0);
3723   }
3724
3725   jresult = result;
3726   return jresult;
3727 }
3728
3729
3730 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
3731   bool jresult ;
3732   Dali::Radian arg1 ;
3733   Dali::Radian arg2 ;
3734   Dali::Radian *argp1 ;
3735   Dali::Radian *argp2 ;
3736   bool result;
3737
3738   argp1 = (Dali::Radian *)jarg1;
3739   if (!argp1) {
3740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3741     return 0;
3742   }
3743   arg1 = *argp1;
3744   argp2 = (Dali::Radian *)jarg2;
3745   if (!argp2) {
3746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3747     return 0;
3748   }
3749   arg2 = *argp2;
3750   {
3751     try {
3752       result = (bool)Dali::operator <(arg1,arg2);
3753     } CALL_CATCH_EXCEPTION(0);
3754   }
3755
3756   jresult = result;
3757   return jresult;
3758 }
3759
3760
3761 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
3762   bool jresult ;
3763   Dali::Radian arg1 ;
3764   Dali::Degree arg2 ;
3765   Dali::Radian *argp1 ;
3766   Dali::Degree *argp2 ;
3767   bool result;
3768
3769   argp1 = (Dali::Radian *)jarg1;
3770   if (!argp1) {
3771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3772     return 0;
3773   }
3774   arg1 = *argp1;
3775   argp2 = (Dali::Degree *)jarg2;
3776   if (!argp2) {
3777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3778     return 0;
3779   }
3780   arg2 = *argp2;
3781   {
3782     try {
3783       result = (bool)Dali::operator <(arg1,arg2);
3784     } CALL_CATCH_EXCEPTION(0);
3785   }
3786
3787   jresult = result;
3788   return jresult;
3789 }
3790
3791
3792 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
3793   bool jresult ;
3794   Dali::Degree arg1 ;
3795   Dali::Radian arg2 ;
3796   Dali::Degree *argp1 ;
3797   Dali::Radian *argp2 ;
3798   bool result;
3799
3800   argp1 = (Dali::Degree *)jarg1;
3801   if (!argp1) {
3802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
3803     return 0;
3804   }
3805   arg1 = *argp1;
3806   argp2 = (Dali::Radian *)jarg2;
3807   if (!argp2) {
3808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3809     return 0;
3810   }
3811   arg2 = *argp2;
3812   {
3813     try {
3814       result = (bool)Dali::operator <(arg1,arg2);
3815     } CALL_CATCH_EXCEPTION(0);
3816   }
3817
3818   jresult = result;
3819   return jresult;
3820 }
3821
3822
3823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
3824   void * jresult ;
3825   Dali::Radian arg1 ;
3826   float arg2 ;
3827   Dali::Radian *argp1 ;
3828   Dali::Radian result;
3829
3830   argp1 = (Dali::Radian *)jarg1;
3831   if (!argp1) {
3832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3833     return 0;
3834   }
3835   arg1 = *argp1;
3836   arg2 = (float)jarg2;
3837   {
3838     try {
3839       result = Dali::operator *(arg1,arg2);
3840     } CALL_CATCH_EXCEPTION(0);
3841   }
3842
3843   jresult = new Dali::Radian((const Dali::Radian &)result);
3844   return jresult;
3845 }
3846
3847
3848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
3849   void * jresult ;
3850   Dali::Radian arg1 ;
3851   Dali::Radian *argp1 ;
3852   Dali::Radian result;
3853
3854   argp1 = (Dali::Radian *)jarg1;
3855   if (!argp1) {
3856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3857     return 0;
3858   }
3859   arg1 = *argp1;
3860   {
3861     try {
3862       result = Dali::operator -(arg1);
3863     } CALL_CATCH_EXCEPTION(0);
3864   }
3865
3866   jresult = new Dali::Radian((const Dali::Radian &)result);
3867   return jresult;
3868 }
3869
3870
3871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
3872   void * jresult ;
3873   Dali::Radian arg1 ;
3874   float arg2 ;
3875   float arg3 ;
3876   Dali::Radian *argp1 ;
3877   Dali::Radian result;
3878
3879   argp1 = (Dali::Radian *)jarg1;
3880   if (!argp1) {
3881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
3882     return 0;
3883   }
3884   arg1 = *argp1;
3885   arg2 = (float)jarg2;
3886   arg3 = (float)jarg3;
3887   {
3888     try {
3889       result = Dali::Clamp(arg1,arg2,arg3);
3890     } CALL_CATCH_EXCEPTION(0);
3891   }
3892
3893   jresult = new Dali::Radian((const Dali::Radian &)result);
3894   return jresult;
3895 }
3896
3897
3898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
3899   void * jresult ;
3900   Dali::Matrix *result = 0 ;
3901
3902   {
3903     try {
3904       result = (Dali::Matrix *)new Dali::Matrix();
3905     } CALL_CATCH_EXCEPTION(0);
3906   }
3907
3908   jresult = (void *)result;
3909   return jresult;
3910 }
3911
3912
3913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(bool jarg1) {
3914   void * jresult ;
3915   bool arg1 ;
3916   Dali::Matrix *result = 0 ;
3917
3918   arg1 = jarg1 ? true : false;
3919   {
3920     try {
3921       result = (Dali::Matrix *)new Dali::Matrix(arg1);
3922     } CALL_CATCH_EXCEPTION(0);
3923   }
3924
3925   jresult = (void *)result;
3926   return jresult;
3927 }
3928
3929
3930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
3931   void * jresult ;
3932   float *arg1 = (float *) 0 ;
3933   Dali::Matrix *result = 0 ;
3934
3935   arg1 = jarg1;
3936   {
3937     try {
3938       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
3939     } CALL_CATCH_EXCEPTION(0);
3940   }
3941
3942   jresult = (void *)result;
3943
3944
3945   return jresult;
3946 }
3947
3948
3949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
3950   void * jresult ;
3951   Dali::Quaternion *arg1 = 0 ;
3952   Dali::Matrix *result = 0 ;
3953
3954   arg1 = (Dali::Quaternion *)jarg1;
3955   if (!arg1) {
3956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
3957     return 0;
3958   }
3959   {
3960     try {
3961       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
3962     } CALL_CATCH_EXCEPTION(0);
3963   }
3964
3965   jresult = (void *)result;
3966   return jresult;
3967 }
3968
3969
3970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
3971   void * jresult ;
3972   Dali::Matrix *arg1 = 0 ;
3973   Dali::Matrix *result = 0 ;
3974
3975   arg1 = (Dali::Matrix *)jarg1;
3976   if (!arg1) {
3977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
3978     return 0;
3979   }
3980   {
3981     try {
3982       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
3983     } CALL_CATCH_EXCEPTION(0);
3984   }
3985
3986   jresult = (void *)result;
3987   return jresult;
3988 }
3989
3990
3991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
3992   void * jresult ;
3993   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
3994   Dali::Matrix *arg2 = 0 ;
3995   Dali::Matrix *result = 0 ;
3996
3997   arg1 = (Dali::Matrix *)jarg1;
3998   arg2 = (Dali::Matrix *)jarg2;
3999   if (!arg2) {
4000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4001     return 0;
4002   }
4003   {
4004     try {
4005       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
4006     } CALL_CATCH_EXCEPTION(0);
4007   }
4008
4009   jresult = (void *)result;
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
4015   void * jresult ;
4016   Dali::Matrix *result = 0 ;
4017
4018   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
4019   jresult = (void *)result;
4020   return jresult;
4021 }
4022
4023
4024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
4025   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4026
4027   arg1 = (Dali::Matrix *)jarg1;
4028   {
4029     try {
4030       (arg1)->SetIdentity();
4031     } CALL_CATCH_EXCEPTION();
4032   }
4033
4034 }
4035
4036
4037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
4038   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4039   Dali::Vector3 *arg2 = 0 ;
4040
4041   arg1 = (Dali::Matrix *)jarg1;
4042   arg2 = (Dali::Vector3 *)jarg2;
4043   if (!arg2) {
4044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4045     return ;
4046   }
4047   {
4048     try {
4049       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
4050     } CALL_CATCH_EXCEPTION();
4051   }
4052
4053 }
4054
4055
4056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
4057   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4058   Dali::Matrix *arg2 = 0 ;
4059
4060   arg1 = (Dali::Matrix *)jarg1;
4061   arg2 = (Dali::Matrix *)jarg2;
4062   if (!arg2) {
4063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
4064     return ;
4065   }
4066   {
4067     try {
4068       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
4069     } CALL_CATCH_EXCEPTION();
4070   }
4071
4072 }
4073
4074
4075 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
4076   bool jresult ;
4077   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4078   bool result;
4079
4080   arg1 = (Dali::Matrix *)jarg1;
4081   {
4082     try {
4083       result = (bool)(arg1)->Invert();
4084     } CALL_CATCH_EXCEPTION(0);
4085   }
4086
4087   jresult = result;
4088   return jresult;
4089 }
4090
4091
4092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
4093   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4094
4095   arg1 = (Dali::Matrix *)jarg1;
4096   {
4097     try {
4098       (arg1)->Transpose();
4099     } CALL_CATCH_EXCEPTION();
4100   }
4101
4102 }
4103
4104
4105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
4106   void * jresult ;
4107   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4108   Dali::Vector3 result;
4109
4110   arg1 = (Dali::Matrix *)jarg1;
4111   {
4112     try {
4113       result = ((Dali::Matrix const *)arg1)->GetXAxis();
4114     } CALL_CATCH_EXCEPTION(0);
4115   }
4116
4117   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4118   return jresult;
4119 }
4120
4121
4122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
4123   void * jresult ;
4124   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4125   Dali::Vector3 result;
4126
4127   arg1 = (Dali::Matrix *)jarg1;
4128   {
4129     try {
4130       result = ((Dali::Matrix const *)arg1)->GetYAxis();
4131     } CALL_CATCH_EXCEPTION(0);
4132   }
4133
4134   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
4140   void * jresult ;
4141   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4142   Dali::Vector3 result;
4143
4144   arg1 = (Dali::Matrix *)jarg1;
4145   {
4146     try {
4147       result = ((Dali::Matrix const *)arg1)->GetZAxis();
4148     } CALL_CATCH_EXCEPTION(0);
4149   }
4150
4151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
4152   return jresult;
4153 }
4154
4155
4156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
4157   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4158   Dali::Vector3 *arg2 = 0 ;
4159
4160   arg1 = (Dali::Matrix *)jarg1;
4161   arg2 = (Dali::Vector3 *)jarg2;
4162   if (!arg2) {
4163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4164     return ;
4165   }
4166   {
4167     try {
4168       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
4169     } CALL_CATCH_EXCEPTION();
4170   }
4171
4172 }
4173
4174
4175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
4176   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4177   Dali::Vector3 *arg2 = 0 ;
4178
4179   arg1 = (Dali::Matrix *)jarg1;
4180   arg2 = (Dali::Vector3 *)jarg2;
4181   if (!arg2) {
4182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4183     return ;
4184   }
4185   {
4186     try {
4187       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
4188     } CALL_CATCH_EXCEPTION();
4189   }
4190
4191 }
4192
4193
4194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
4195   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4196   Dali::Vector3 *arg2 = 0 ;
4197
4198   arg1 = (Dali::Matrix *)jarg1;
4199   arg2 = (Dali::Vector3 *)jarg2;
4200   if (!arg2) {
4201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4202     return ;
4203   }
4204   {
4205     try {
4206       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
4207     } CALL_CATCH_EXCEPTION();
4208   }
4209
4210 }
4211
4212
4213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
4214   void * jresult ;
4215   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4216   Dali::Vector4 *result = 0 ;
4217
4218   arg1 = (Dali::Matrix *)jarg1;
4219   {
4220     try {
4221       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
4222     } CALL_CATCH_EXCEPTION(0);
4223   }
4224
4225   jresult = (void *)result;
4226   return jresult;
4227 }
4228
4229
4230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
4231   void * jresult ;
4232   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4233   Dali::Vector3 *result = 0 ;
4234
4235   arg1 = (Dali::Matrix *)jarg1;
4236   {
4237     try {
4238       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
4239     } CALL_CATCH_EXCEPTION(0);
4240   }
4241
4242   jresult = (void *)result;
4243   return jresult;
4244 }
4245
4246
4247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
4248   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4249   Dali::Vector4 *arg2 = 0 ;
4250
4251   arg1 = (Dali::Matrix *)jarg1;
4252   arg2 = (Dali::Vector4 *)jarg2;
4253   if (!arg2) {
4254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4255     return ;
4256   }
4257   {
4258     try {
4259       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
4260     } CALL_CATCH_EXCEPTION();
4261   }
4262
4263 }
4264
4265
4266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
4267   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4268   Dali::Vector3 *arg2 = 0 ;
4269
4270   arg1 = (Dali::Matrix *)jarg1;
4271   arg2 = (Dali::Vector3 *)jarg2;
4272   if (!arg2) {
4273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4274     return ;
4275   }
4276   {
4277     try {
4278       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
4279     } CALL_CATCH_EXCEPTION();
4280   }
4281
4282 }
4283
4284
4285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
4286   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4287
4288   arg1 = (Dali::Matrix *)jarg1;
4289   {
4290     try {
4291       (arg1)->OrthoNormalize();
4292     } CALL_CATCH_EXCEPTION();
4293   }
4294
4295 }
4296
4297
4298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
4299   void * jresult ;
4300   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4301   float *result = 0 ;
4302
4303   arg1 = (Dali::Matrix *)jarg1;
4304   {
4305     try {
4306       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
4307     } CALL_CATCH_EXCEPTION(0);
4308   }
4309
4310   jresult = (void *)result;
4311   return jresult;
4312 }
4313
4314
4315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
4316   Dali::Matrix *arg1 = 0 ;
4317   Dali::Matrix *arg2 = 0 ;
4318   Dali::Matrix *arg3 = 0 ;
4319
4320   arg1 = (Dali::Matrix *)jarg1;
4321   if (!arg1) {
4322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
4323     return ;
4324   }
4325   arg2 = (Dali::Matrix *)jarg2;
4326   if (!arg2) {
4327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4328     return ;
4329   }
4330   arg3 = (Dali::Matrix *)jarg3;
4331   if (!arg3) {
4332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4333     return ;
4334   }
4335   {
4336     try {
4337       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
4338     } CALL_CATCH_EXCEPTION();
4339   }
4340
4341 }
4342
4343
4344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
4345   Dali::Matrix *arg1 = 0 ;
4346   Dali::Matrix *arg2 = 0 ;
4347   Dali::Quaternion *arg3 = 0 ;
4348
4349   arg1 = (Dali::Matrix *)jarg1;
4350   if (!arg1) {
4351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
4352     return ;
4353   }
4354   arg2 = (Dali::Matrix *)jarg2;
4355   if (!arg2) {
4356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4357     return ;
4358   }
4359   arg3 = (Dali::Quaternion *)jarg3;
4360   if (!arg3) {
4361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4362     return ;
4363   }
4364   {
4365     try {
4366       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
4367     } CALL_CATCH_EXCEPTION();
4368   }
4369
4370 }
4371
4372
4373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
4374   void * jresult ;
4375   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4376   Dali::Vector4 *arg2 = 0 ;
4377   Dali::Vector4 result;
4378
4379   arg1 = (Dali::Matrix *)jarg1;
4380   if (!arg1) {
4381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4382     return 0;
4383   }
4384   arg2 = (Dali::Vector4 *)jarg2;
4385   if (!arg2) {
4386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4387     return 0;
4388   }
4389   {
4390     try {
4391       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
4392     } CALL_CATCH_EXCEPTION(0);
4393   }
4394
4395   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
4396   return jresult;
4397 }
4398
4399
4400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_3(void * nuiMatrixLhs, void * nuiMatrixRhs) {
4401   void * jresult ;
4402   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
4403   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
4404   Dali::Matrix result(false);
4405
4406   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
4407   if (!lhsPtr) {
4408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
4409     return 0;
4410   }
4411   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
4412   if (!rhsPtr) {
4413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
4414     return 0;
4415   }
4416   {
4417     try {
4418       result = ((Dali::Matrix const *)lhsPtr)->operator *((Dali::Matrix const &)*rhsPtr);
4419     } CALL_CATCH_EXCEPTION(0);
4420   }
4421
4422   jresult = new Dali::Matrix((const Dali::Matrix &)result);
4423   return jresult;
4424 }
4425
4426
4427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_4(void * nuiMatrixLhs, void * nuiMatrixRhs) {
4428   // Faster mulitply operation without memcpy
4429
4430   Dali::Matrix *jresult = (Dali::Matrix *)0;
4431   Dali::Matrix *lhsPtr  = (Dali::Matrix *)0;
4432   Dali::Matrix *rhsPtr  = (Dali::Matrix *)0;
4433
4434   lhsPtr = (Dali::Matrix *)nuiMatrixLhs;
4435   if (!lhsPtr) {
4436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
4437     return 0;
4438   }
4439   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
4440   if (!rhsPtr) {
4441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
4442     return 0;
4443   }
4444   {
4445     try {
4446       jresult = new Dali::Matrix(false);
4447       Dali::Matrix::Multiply((Dali::Matrix &)*jresult,(Dali::Matrix const &)*rhsPtr,(Dali::Matrix const &)*lhsPtr);
4448     } CALL_CATCH_EXCEPTION(0);
4449   }
4450
4451   return jresult;
4452 }
4453
4454
4455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
4456   void * jresult = 0;
4457   Dali::Matrix *lhsPtr = (Dali::Matrix *) 0 ;
4458   Dali::Matrix *rhsPtr = (Dali::Matrix *) 0 ;
4459   Dali::Matrix *retPtr = (Dali::Matrix *) 0 ;
4460
4461   lhsPtr = (Dali::Matrix *)nuiMatrix;
4462   if (!lhsPtr) {
4463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix const & type is null", 0);
4464     return 0;
4465   }
4466   rhsPtr = (Dali::Matrix *)nuiMatrixRhs;
4467   if (!rhsPtr) {
4468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix const & type is null", 0);
4469     return 0;
4470   }
4471   {
4472     try {
4473       retPtr = (Dali::Matrix *) &(lhsPtr)->operator *=((Dali::Matrix const &)*rhsPtr);
4474     } CALL_CATCH_EXCEPTION(0);
4475   }
4476
4477   jresult = (void *)retPtr;
4478   return jresult;
4479 }
4480
4481
4482 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
4483   bool jresult ;
4484   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4485   Dali::Matrix *arg2 = 0 ;
4486   bool result;
4487
4488   arg1 = (Dali::Matrix *)jarg1;
4489   arg2 = (Dali::Matrix *)jarg2;
4490   if (!arg2) {
4491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4492     return 0;
4493   }
4494   {
4495     try {
4496       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
4497     } CALL_CATCH_EXCEPTION(0);
4498   }
4499
4500   jresult = result;
4501   return jresult;
4502 }
4503
4504
4505 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
4506   bool jresult ;
4507   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4508   Dali::Matrix *arg2 = 0 ;
4509   bool result;
4510
4511   arg1 = (Dali::Matrix *)jarg1;
4512   arg2 = (Dali::Matrix *)jarg2;
4513   if (!arg2) {
4514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4515     return 0;
4516   }
4517   {
4518     try {
4519       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
4520     } CALL_CATCH_EXCEPTION(0);
4521   }
4522
4523   jresult = result;
4524   return jresult;
4525 }
4526
4527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
4528   float jresult ;
4529   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4530
4531   pMatrix = (Dali::Matrix *)nuiMatrix;
4532   if (!pMatrix) {
4533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4534     return 0;
4535   }
4536   if (index >= 16) {
4537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
4538     return 0;
4539   }
4540   {
4541     try {
4542       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
4543       jresult = temp[index];
4544     } CALL_CATCH_EXCEPTION(0);
4545   }
4546   return jresult;
4547 }
4548
4549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
4550   float jresult ;
4551   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4552
4553   pMatrix = (Dali::Matrix *)nuiMatrix;
4554   if (!pMatrix) {
4555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4556     return 0;
4557   }
4558   if (indexRow >= 4) {
4559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
4560     return 0;
4561   }
4562   if (indexColumn >= 4) {
4563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
4564     return 0;
4565   }
4566   {
4567     try {
4568       const float* temp = ((Dali::Matrix const *)pMatrix)->AsFloat();
4569       jresult = temp[(indexColumn << 2) | indexRow];
4570     } CALL_CATCH_EXCEPTION(0);
4571   }
4572   return jresult;
4573 }
4574
4575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
4576   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4577
4578   pMatrix = (Dali::Matrix *)nuiMatrix;
4579   if (!pMatrix) {
4580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4581     return;
4582   }
4583   if (index >= 16) {
4584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 16.)", 0);
4585     return;
4586   }
4587   {
4588     try {
4589       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
4590       temp[index] = value;
4591     } CALL_CATCH_EXCEPTION();
4592   }
4593 }
4594
4595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
4596   Dali::Matrix *pMatrix = (Dali::Matrix *) 0 ;
4597
4598   pMatrix = (Dali::Matrix *)nuiMatrix;
4599   if (!pMatrix) {
4600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4601     return;
4602   }
4603   if (indexRow >= 4) {
4604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 4.)", 0);
4605     return;
4606   }
4607   if (indexColumn >= 4) {
4608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 4.)", 0);
4609     return;
4610   }
4611   {
4612     try {
4613       float* temp = ((Dali::Matrix *)pMatrix)->AsFloat();
4614       temp[(indexColumn << 2) | indexRow] = value;
4615     } CALL_CATCH_EXCEPTION();
4616   }
4617 }
4618
4619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
4620   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4621   Dali::Vector3 *arg2 = 0 ;
4622   Dali::Quaternion *arg3 = 0 ;
4623   Dali::Vector3 *arg4 = 0 ;
4624
4625   arg1 = (Dali::Matrix *)jarg1;
4626   arg2 = (Dali::Vector3 *)jarg2;
4627   if (!arg2) {
4628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4629     return ;
4630   }
4631   arg3 = (Dali::Quaternion *)jarg3;
4632   if (!arg3) {
4633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4634     return ;
4635   }
4636   arg4 = (Dali::Vector3 *)jarg4;
4637   if (!arg4) {
4638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4639     return ;
4640   }
4641   {
4642     try {
4643       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
4644     } CALL_CATCH_EXCEPTION();
4645   }
4646
4647 }
4648
4649
4650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
4651   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4652   Dali::Vector3 *arg2 = 0 ;
4653   Dali::Quaternion *arg3 = 0 ;
4654   Dali::Vector3 *arg4 = 0 ;
4655
4656   arg1 = (Dali::Matrix *)jarg1;
4657   arg2 = (Dali::Vector3 *)jarg2;
4658   if (!arg2) {
4659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4660     return ;
4661   }
4662   arg3 = (Dali::Quaternion *)jarg3;
4663   if (!arg3) {
4664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
4665     return ;
4666   }
4667   arg4 = (Dali::Vector3 *)jarg4;
4668   if (!arg4) {
4669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4670     return ;
4671   }
4672   {
4673     try {
4674       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
4675     } CALL_CATCH_EXCEPTION();
4676   }
4677
4678 }
4679
4680
4681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
4682   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4683   Dali::Vector3 *arg2 = 0 ;
4684   Dali::Vector3 *arg3 = 0 ;
4685   Dali::Vector3 *arg4 = 0 ;
4686   Dali::Vector3 *arg5 = 0 ;
4687
4688   arg1 = (Dali::Matrix *)jarg1;
4689   arg2 = (Dali::Vector3 *)jarg2;
4690   if (!arg2) {
4691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4692     return ;
4693   }
4694   arg3 = (Dali::Vector3 *)jarg3;
4695   if (!arg3) {
4696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4697     return ;
4698   }
4699   arg4 = (Dali::Vector3 *)jarg4;
4700   if (!arg4) {
4701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4702     return ;
4703   }
4704   arg5 = (Dali::Vector3 *)jarg5;
4705   if (!arg5) {
4706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4707     return ;
4708   }
4709   {
4710     try {
4711       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
4712     } CALL_CATCH_EXCEPTION();
4713   }
4714
4715 }
4716
4717
4718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
4719   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4720   Dali::Vector3 *arg2 = 0 ;
4721   Dali::Quaternion *arg3 = 0 ;
4722   Dali::Vector3 *arg4 = 0 ;
4723
4724   arg1 = (Dali::Matrix *)jarg1;
4725   arg2 = (Dali::Vector3 *)jarg2;
4726   if (!arg2) {
4727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
4728     return ;
4729   }
4730   arg3 = (Dali::Quaternion *)jarg3;
4731   if (!arg3) {
4732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
4733     return ;
4734   }
4735   arg4 = (Dali::Vector3 *)jarg4;
4736   if (!arg4) {
4737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
4738     return ;
4739   }
4740   {
4741     try {
4742       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
4743     } CALL_CATCH_EXCEPTION();
4744   }
4745
4746 }
4747
4748
4749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
4750   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
4751
4752   arg1 = (Dali::Matrix *)jarg1;
4753   {
4754     try {
4755       delete arg1;
4756     } CALL_CATCH_EXCEPTION();
4757   }
4758
4759 }
4760
4761
4762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
4763   void * jresult ;
4764   Dali::Matrix3 *result = 0 ;
4765
4766   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
4767   jresult = (void *)result;
4768   return jresult;
4769 }
4770
4771
4772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
4773   void * jresult ;
4774   Dali::Matrix3 *result = 0 ;
4775
4776   {
4777     try {
4778       result = (Dali::Matrix3 *)new Dali::Matrix3();
4779     } CALL_CATCH_EXCEPTION(0);
4780   }
4781
4782   jresult = (void *)result;
4783   return jresult;
4784 }
4785
4786
4787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
4788   void * jresult ;
4789   Dali::Matrix3 *arg1 = 0 ;
4790   Dali::Matrix3 *result = 0 ;
4791
4792   arg1 = (Dali::Matrix3 *)jarg1;
4793   if (!arg1) {
4794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4795     return 0;
4796   }
4797   {
4798     try {
4799       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
4800     } CALL_CATCH_EXCEPTION(0);
4801   }
4802
4803   jresult = (void *)result;
4804   return jresult;
4805 }
4806
4807
4808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
4809   void * jresult ;
4810   Dali::Matrix *arg1 = 0 ;
4811   Dali::Matrix3 *result = 0 ;
4812
4813   arg1 = (Dali::Matrix *)jarg1;
4814   if (!arg1) {
4815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4816     return 0;
4817   }
4818   {
4819     try {
4820       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
4821     } CALL_CATCH_EXCEPTION(0);
4822   }
4823
4824   jresult = (void *)result;
4825   return jresult;
4826 }
4827
4828
4829 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) {
4830   void * jresult ;
4831   float arg1 ;
4832   float arg2 ;
4833   float arg3 ;
4834   float arg4 ;
4835   float arg5 ;
4836   float arg6 ;
4837   float arg7 ;
4838   float arg8 ;
4839   float arg9 ;
4840   Dali::Matrix3 *result = 0 ;
4841
4842   arg1 = (float)jarg1;
4843   arg2 = (float)jarg2;
4844   arg3 = (float)jarg3;
4845   arg4 = (float)jarg4;
4846   arg5 = (float)jarg5;
4847   arg6 = (float)jarg6;
4848   arg7 = (float)jarg7;
4849   arg8 = (float)jarg8;
4850   arg9 = (float)jarg9;
4851   {
4852     try {
4853       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
4854     } CALL_CATCH_EXCEPTION(0);
4855   }
4856
4857   jresult = (void *)result;
4858   return jresult;
4859 }
4860
4861
4862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
4863   void * jresult ;
4864   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4865   Dali::Matrix3 *arg2 = 0 ;
4866   Dali::Matrix3 *result = 0 ;
4867
4868   arg1 = (Dali::Matrix3 *)jarg1;
4869   arg2 = (Dali::Matrix3 *)jarg2;
4870   if (!arg2) {
4871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4872     return 0;
4873   }
4874   {
4875     try {
4876       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
4877     } CALL_CATCH_EXCEPTION(0);
4878   }
4879
4880   jresult = (void *)result;
4881   return jresult;
4882 }
4883
4884
4885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
4886   void * jresult ;
4887   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4888   Dali::Matrix *arg2 = 0 ;
4889   Dali::Matrix3 *result = 0 ;
4890
4891   arg1 = (Dali::Matrix3 *)jarg1;
4892   arg2 = (Dali::Matrix *)jarg2;
4893   if (!arg2) {
4894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
4895     return 0;
4896   }
4897   {
4898     try {
4899       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
4900     } CALL_CATCH_EXCEPTION(0);
4901   }
4902
4903   jresult = (void *)result;
4904   return jresult;
4905 }
4906
4907
4908 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
4909   bool jresult ;
4910   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4911   Dali::Matrix3 *arg2 = 0 ;
4912   bool result;
4913
4914   arg1 = (Dali::Matrix3 *)jarg1;
4915   arg2 = (Dali::Matrix3 *)jarg2;
4916   if (!arg2) {
4917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4918     return 0;
4919   }
4920   {
4921     try {
4922       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
4923     } CALL_CATCH_EXCEPTION(0);
4924   }
4925
4926   jresult = result;
4927   return jresult;
4928 }
4929
4930
4931 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
4932   bool jresult ;
4933   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
4934   Dali::Matrix3 *arg2 = 0 ;
4935   bool result;
4936
4937   arg1 = (Dali::Matrix3 *)jarg1;
4938   arg2 = (Dali::Matrix3 *)jarg2;
4939   if (!arg2) {
4940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4941     return 0;
4942   }
4943   {
4944     try {
4945       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
4946     } CALL_CATCH_EXCEPTION(0);
4947   }
4948
4949   jresult = result;
4950   return jresult;
4951 }
4952
4953
4954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_0(void * nuiMatrix, unsigned int index) {
4955   float jresult ;
4956   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
4957
4958   pMatrix = (Dali::Matrix3 *)nuiMatrix;
4959   if (!pMatrix) {
4960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4961     return 0;
4962   }
4963   if (index >= 9) {
4964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
4965     return 0;
4966   }
4967   {
4968     try {
4969       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
4970       jresult = temp[index];
4971     } CALL_CATCH_EXCEPTION(0);
4972   }
4973   return jresult;
4974 }
4975
4976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_ValueOfIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn) {
4977   float jresult ;
4978   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
4979
4980   pMatrix = (Dali::Matrix3 *)nuiMatrix;
4981   if (!pMatrix) {
4982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
4983     return 0;
4984   }
4985   if (indexRow >= 3) {
4986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
4987     return 0;
4988   }
4989   if (indexColumn >= 3) {
4990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
4991     return 0;
4992   }
4993   {
4994     try {
4995       const float* temp = ((Dali::Matrix3 const *)pMatrix)->AsFloat();
4996       jresult = temp[indexColumn * 3 + indexRow];
4997     } CALL_CATCH_EXCEPTION(0);
4998   }
4999   return jresult;
5000 }
5001
5002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_0(void * nuiMatrix, unsigned int index, float value) {
5003   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
5004
5005   pMatrix = (Dali::Matrix3 *)nuiMatrix;
5006   if (!pMatrix) {
5007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5008     return;
5009   }
5010   if (index >= 9) {
5011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "index is out of range. (Check whether index >= 9.)", 0);
5012     return;
5013   }
5014   {
5015     try {
5016       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
5017       temp[index] = value;
5018     } CALL_CATCH_EXCEPTION();
5019   }
5020 }
5021
5022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetValueAtIndex__SWIG_1(void * nuiMatrix, unsigned int indexRow, unsigned int indexColumn, float value) {
5023   Dali::Matrix3 *pMatrix = (Dali::Matrix3 *) 0 ;
5024
5025   pMatrix = (Dali::Matrix3 *)nuiMatrix;
5026   if (!pMatrix) {
5027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5028     return;
5029   }
5030   if (indexRow >= 3) {
5031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexRow is out of range. (Check whether indexRow >= 3.)", 0);
5032     return;
5033   }
5034   if (indexColumn >= 3) {
5035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, "indexColumn is out of range. (Check whether indexColumn >= 3.)", 0);
5036     return;
5037   }
5038   {
5039     try {
5040       float* temp = ((Dali::Matrix3 *)pMatrix)->AsFloat();
5041       temp[indexColumn * 3 + indexRow] = value;
5042     } CALL_CATCH_EXCEPTION();
5043   }
5044 }
5045
5046
5047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
5048   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5049
5050   arg1 = (Dali::Matrix3 *)jarg1;
5051   {
5052     try {
5053       delete arg1;
5054     } CALL_CATCH_EXCEPTION();
5055   }
5056
5057 }
5058
5059
5060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
5061   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5062
5063   arg1 = (Dali::Matrix3 *)jarg1;
5064   {
5065     try {
5066       (arg1)->SetIdentity();
5067     } CALL_CATCH_EXCEPTION();
5068   }
5069
5070 }
5071
5072
5073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
5074   void * jresult ;
5075   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5076   float *result = 0 ;
5077
5078   arg1 = (Dali::Matrix3 *)jarg1;
5079   {
5080     try {
5081       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
5082     } CALL_CATCH_EXCEPTION(0);
5083   }
5084
5085   jresult = (void *)result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
5091   bool jresult ;
5092   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5093   bool result;
5094
5095   arg1 = (Dali::Matrix3 *)jarg1;
5096   {
5097     try {
5098       result = (bool)(arg1)->Invert();
5099     } CALL_CATCH_EXCEPTION(0);
5100   }
5101
5102   jresult = result;
5103   return jresult;
5104 }
5105
5106
5107 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
5108   bool jresult ;
5109   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5110   bool result;
5111
5112   arg1 = (Dali::Matrix3 *)jarg1;
5113   {
5114     try {
5115       result = (bool)(arg1)->Transpose();
5116     } CALL_CATCH_EXCEPTION(0);
5117   }
5118
5119   jresult = result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
5125   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5126   float arg2 ;
5127
5128   arg1 = (Dali::Matrix3 *)jarg1;
5129   arg2 = (float)jarg2;
5130   {
5131     try {
5132       (arg1)->Scale(arg2);
5133     } CALL_CATCH_EXCEPTION();
5134   }
5135
5136 }
5137
5138
5139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
5140   float jresult ;
5141   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5142   float result;
5143
5144   arg1 = (Dali::Matrix3 *)jarg1;
5145   {
5146     try {
5147       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
5148     } CALL_CATCH_EXCEPTION(0);
5149   }
5150
5151   jresult = result;
5152   return jresult;
5153 }
5154
5155
5156 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
5157   bool jresult ;
5158   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
5159   bool result;
5160
5161   arg1 = (Dali::Matrix3 *)jarg1;
5162   {
5163     try {
5164       result = (bool)(arg1)->ScaledInverseTranspose();
5165     } CALL_CATCH_EXCEPTION(0);
5166   }
5167
5168   jresult = result;
5169   return jresult;
5170 }
5171
5172
5173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
5174   Dali::Matrix3 *arg1 = 0 ;
5175   Dali::Matrix3 *arg2 = 0 ;
5176   Dali::Matrix3 *arg3 = 0 ;
5177
5178   arg1 = (Dali::Matrix3 *)jarg1;
5179   if (!arg1) {
5180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
5181     return ;
5182   }
5183   arg2 = (Dali::Matrix3 *)jarg2;
5184   if (!arg2) {
5185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5186     return ;
5187   }
5188   arg3 = (Dali::Matrix3 *)jarg3;
5189   if (!arg3) {
5190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5191     return ;
5192   }
5193   {
5194     try {
5195       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
5196     } CALL_CATCH_EXCEPTION();
5197   }
5198
5199 }
5200
5201
5202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_1(void * jarg1, void * jarg2) {
5203   void * jresult ;
5204   Dali::Matrix3 *arg1 = 0 ;
5205   Dali::Vector3 *arg2 = 0 ;
5206   Dali::Vector3 result;
5207
5208   arg1 = (Dali::Matrix3 *)jarg1;
5209   if (!arg1) {
5210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
5211     return 0;
5212   }
5213   arg2 = (Dali::Vector3 *)jarg2;
5214   if (!arg2) {
5215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5216     return 0;
5217   }
5218   {
5219     try {
5220       result = ((Dali::Matrix3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5221     } CALL_CATCH_EXCEPTION(0);
5222   }
5223
5224   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5225   return jresult;
5226 }
5227
5228
5229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_2(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
5230   void * jresult ;
5231   Dali::Matrix3 *lhsPtr = 0 ;
5232   Dali::Matrix3 *rhsPtr = 0 ;
5233   Dali::Matrix3 result;
5234
5235   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
5236   if (!lhsPtr) {
5237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
5238     return 0;
5239   }
5240   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
5241   if (!rhsPtr) {
5242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
5243     return 0;
5244   }
5245   {
5246     try {
5247       result = ((Dali::Matrix3 const *)lhsPtr)->operator *((Dali::Matrix3 const &)*rhsPtr);
5248     } CALL_CATCH_EXCEPTION(0);
5249   }
5250
5251   jresult = new Dali::Matrix3((const Dali::Matrix3 &)result);
5252   return jresult;
5253 }
5254
5255
5256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Multiply__SWIG_3(void * nuiMatrix3Lhs, void * nuiMatrix3Rhs) {
5257   // Faster mulitply operation without memcpy
5258
5259   Dali::Matrix3 *jresult = 0;
5260   Dali::Matrix3 *lhsPtr  = 0;
5261   Dali::Matrix3 *rhsPtr  = 0;
5262
5263   lhsPtr = (Dali::Matrix3 *)nuiMatrix3Lhs;
5264   if (!lhsPtr) {
5265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
5266     return 0;
5267   }
5268   rhsPtr = (Dali::Matrix3 *)nuiMatrix3Rhs;
5269   if (!rhsPtr) {
5270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
5271     return 0;
5272   }
5273   {
5274     try {
5275       jresult = new Dali::Matrix3();
5276       Dali::Matrix3::Multiply((Dali::Matrix3 &)*jresult,(Dali::Matrix3 const &)*rhsPtr,(Dali::Matrix3 const &)*lhsPtr);
5277     } CALL_CATCH_EXCEPTION(0);
5278   }
5279
5280   return jresult;
5281 }
5282
5283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_MultiplyAssign(void * nuiMatrix, void * nuiMatrixRhs) {
5284   void * jresult = 0;
5285   Dali::Matrix3 *lhsPtr = (Dali::Matrix3 *) 0 ;
5286   Dali::Matrix3 *rhsPtr = (Dali::Matrix3 *) 0 ;
5287   Dali::Matrix3 *retPtr = (Dali::Matrix3 *) 0 ;
5288
5289   lhsPtr = (Dali::Matrix3 *)nuiMatrix;
5290   if (!lhsPtr) {
5291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "lhs Dali::Matrix3 const & type is null", 0);
5292     return 0;
5293   }
5294   rhsPtr = (Dali::Matrix3 *)nuiMatrixRhs;
5295   if (!rhsPtr) {
5296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "rhs Dali::Matrix3 const & type is null", 0);
5297     return 0;
5298   }
5299   {
5300     try {
5301       retPtr = (Dali::Matrix3 *) &(lhsPtr)->operator *=((Dali::Matrix3 const &)*rhsPtr);
5302     } CALL_CATCH_EXCEPTION(0);
5303   }
5304
5305   jresult = (void *)retPtr;
5306   return jresult;
5307 }
5308
5309
5310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
5311   float jresult ;
5312   float arg1 ;
5313   float arg2 ;
5314   float result;
5315
5316   arg1 = (float)jarg1;
5317   arg2 = (float)jarg2;
5318   {
5319     try {
5320       result = (float)Dali::Random::Range(arg1,arg2);
5321     } CALL_CATCH_EXCEPTION(0);
5322   }
5323
5324   jresult = result;
5325   return jresult;
5326 }
5327
5328
5329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
5330   void * jresult ;
5331   Dali::Vector4 result;
5332
5333   {
5334     try {
5335       result = Dali::Random::Axis();
5336     } CALL_CATCH_EXCEPTION(0);
5337   }
5338
5339   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
5340   return jresult;
5341 }
5342
5343
5344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
5345   void * jresult ;
5346   Dali::AngleAxis *result = 0 ;
5347
5348   {
5349     try {
5350       result = (Dali::AngleAxis *)new Dali::AngleAxis();
5351     } CALL_CATCH_EXCEPTION(0);
5352   }
5353
5354   jresult = (void *)result;
5355   return jresult;
5356 }
5357
5358
5359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
5360   void * jresult ;
5361   Dali::Radian arg1 ;
5362   Dali::Vector3 *arg2 = 0 ;
5363   Dali::Radian *argp1 ;
5364   Dali::AngleAxis *result = 0 ;
5365
5366   argp1 = (Dali::Radian *)jarg1;
5367   if (!argp1) {
5368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
5369     return 0;
5370   }
5371   arg1 = *argp1;
5372   arg2 = (Dali::Vector3 *)jarg2;
5373   if (!arg2) {
5374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5375     return 0;
5376   }
5377   {
5378     try {
5379       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
5380     } CALL_CATCH_EXCEPTION(0);
5381   }
5382
5383   jresult = (void *)result;
5384   return jresult;
5385 }
5386
5387
5388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
5389   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5390   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
5391
5392   arg1 = (Dali::AngleAxis *)jarg1;
5393   arg2 = (Dali::Radian *)jarg2;
5394   if (arg1) (arg1)->angle = *arg2;
5395 }
5396
5397
5398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
5399   void * jresult ;
5400   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5401   Dali::Radian *result = 0 ;
5402
5403   arg1 = (Dali::AngleAxis *)jarg1;
5404   result = (Dali::Radian *)& ((arg1)->angle);
5405   jresult = (void *)result;
5406   return jresult;
5407 }
5408
5409
5410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
5411   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5412   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
5413
5414   arg1 = (Dali::AngleAxis *)jarg1;
5415   arg2 = (Dali::Vector3 *)jarg2;
5416   if (arg1) (arg1)->axis = *arg2;
5417 }
5418
5419
5420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
5421   void * jresult ;
5422   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5423   Dali::Vector3 *result = 0 ;
5424
5425   arg1 = (Dali::AngleAxis *)jarg1;
5426   result = (Dali::Vector3 *)& ((arg1)->axis);
5427   jresult = (void *)result;
5428   return jresult;
5429 }
5430
5431
5432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
5433   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
5434
5435   arg1 = (Dali::AngleAxis *)jarg1;
5436   {
5437     try {
5438       delete arg1;
5439     } CALL_CATCH_EXCEPTION();
5440   }
5441
5442 }
5443
5444
5445 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
5446   bool jresult ;
5447   Dali::AngleAxis *arg1 = 0 ;
5448   Dali::AngleAxis *arg2 = 0 ;
5449   bool result;
5450
5451   arg1 = (Dali::AngleAxis *)jarg1;
5452   if (!arg1) {
5453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
5454     return 0;
5455   }
5456   arg2 = (Dali::AngleAxis *)jarg2;
5457   if (!arg2) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
5459     return 0;
5460   }
5461   {
5462     try {
5463       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
5464     } CALL_CATCH_EXCEPTION(0);
5465   }
5466
5467   jresult = result;
5468   return jresult;
5469 }
5470
5471
5472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
5473   unsigned int jresult ;
5474   unsigned int arg1 ;
5475   unsigned int result;
5476
5477   arg1 = (unsigned int)jarg1;
5478   {
5479     try {
5480       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
5481     } CALL_CATCH_EXCEPTION(0);
5482   }
5483
5484   jresult = result;
5485   return jresult;
5486 }
5487
5488
5489 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
5490   bool jresult ;
5491   unsigned int arg1 ;
5492   bool result;
5493
5494   arg1 = (unsigned int)jarg1;
5495   {
5496     try {
5497       result = (bool)Dali::IsPowerOfTwo(arg1);
5498     } CALL_CATCH_EXCEPTION(0);
5499   }
5500
5501   jresult = result;
5502   return jresult;
5503 }
5504
5505
5506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
5507   float jresult ;
5508   float arg1 ;
5509   float arg2 ;
5510   float result;
5511
5512   arg1 = (float)jarg1;
5513   arg2 = (float)jarg2;
5514   {
5515     try {
5516       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
5517     } CALL_CATCH_EXCEPTION(0);
5518   }
5519
5520   jresult = result;
5521   return jresult;
5522 }
5523
5524
5525 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
5526   bool jresult ;
5527   float arg1 ;
5528   bool result;
5529
5530   arg1 = (float)jarg1;
5531   {
5532     try {
5533       result = (bool)Dali::EqualsZero(arg1);
5534     } CALL_CATCH_EXCEPTION(0);
5535   }
5536
5537   jresult = result;
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
5543   bool jresult ;
5544   float arg1 ;
5545   float arg2 ;
5546   bool result;
5547
5548   arg1 = (float)jarg1;
5549   arg2 = (float)jarg2;
5550   {
5551     try {
5552       result = (bool)Dali::Equals(arg1,arg2);
5553     } CALL_CATCH_EXCEPTION(0);
5554   }
5555
5556   jresult = result;
5557   return jresult;
5558 }
5559
5560
5561 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
5562   bool jresult ;
5563   float arg1 ;
5564   float arg2 ;
5565   float arg3 ;
5566   bool result;
5567
5568   arg1 = (float)jarg1;
5569   arg2 = (float)jarg2;
5570   arg3 = (float)jarg3;
5571   {
5572     try {
5573       result = (bool)Dali::Equals(arg1,arg2,arg3);
5574     } CALL_CATCH_EXCEPTION(0);
5575   }
5576
5577   jresult = result;
5578   return jresult;
5579 }
5580
5581
5582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
5583   float jresult ;
5584   float arg1 ;
5585   int arg2 ;
5586   float result;
5587
5588   arg1 = (float)jarg1;
5589   arg2 = (int)jarg2;
5590   {
5591     try {
5592       result = (float)Dali::Round(arg1,arg2);
5593     } CALL_CATCH_EXCEPTION(0);
5594   }
5595
5596   jresult = result;
5597   return jresult;
5598 }
5599
5600
5601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
5602   float jresult ;
5603   float arg1 ;
5604   float arg2 ;
5605   float arg3 ;
5606   float result;
5607
5608   arg1 = (float)jarg1;
5609   arg2 = (float)jarg2;
5610   arg3 = (float)jarg3;
5611   {
5612     try {
5613       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
5614     } CALL_CATCH_EXCEPTION(0);
5615   }
5616
5617   jresult = result;
5618   return jresult;
5619 }
5620
5621
5622 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
5623   float jresult ;
5624   float arg1 ;
5625   float arg2 ;
5626   float arg3 ;
5627   float arg4 ;
5628   float result;
5629
5630   arg1 = (float)jarg1;
5631   arg2 = (float)jarg2;
5632   arg3 = (float)jarg3;
5633   arg4 = (float)jarg4;
5634   {
5635     try {
5636       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
5637     } CALL_CATCH_EXCEPTION(0);
5638   }
5639
5640   jresult = result;
5641   return jresult;
5642 }
5643
5644
5645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
5646   void * jresult ;
5647   Dali::Handle *arg1 = 0 ;
5648   Dali::Property::Index arg2 ;
5649   Dali::Property *result = 0 ;
5650
5651   arg1 = (Dali::Handle *)jarg1;
5652   if (!arg1) {
5653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5654     return 0;
5655   }
5656   arg2 = (Dali::Property::Index)jarg2;
5657   {
5658     try {
5659       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
5660     } CALL_CATCH_EXCEPTION(0);
5661   }
5662
5663   jresult = (void *)result;
5664   return jresult;
5665 }
5666
5667
5668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
5669   void * jresult ;
5670   Dali::Handle *arg1 = 0 ;
5671   Dali::Property::Index arg2 ;
5672   int arg3 ;
5673   Dali::Property *result = 0 ;
5674
5675   arg1 = (Dali::Handle *)jarg1;
5676   if (!arg1) {
5677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5678     return 0;
5679   }
5680   arg2 = (Dali::Property::Index)jarg2;
5681   arg3 = (int)jarg3;
5682   {
5683     try {
5684       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
5685     } CALL_CATCH_EXCEPTION(0);
5686   }
5687
5688   jresult = (void *)result;
5689   return jresult;
5690 }
5691
5692
5693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
5694   void * jresult ;
5695   Dali::Handle *arg1 = 0 ;
5696   std::string *arg2 = 0 ;
5697   Dali::Property *result = 0 ;
5698
5699   arg1 = (Dali::Handle *)jarg1;
5700   if (!arg1) {
5701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5702     return 0;
5703   }
5704   if (!jarg2) {
5705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
5706     return 0;
5707   }
5708   std::string arg2_str(jarg2);
5709   arg2 = &arg2_str;
5710   {
5711     try {
5712       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
5713     } CALL_CATCH_EXCEPTION(0);
5714   }
5715
5716   jresult = (void *)result;
5717
5718   //argout typemap for const std::string&
5719
5720   return jresult;
5721 }
5722
5723
5724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
5725   void * jresult ;
5726   Dali::Handle *arg1 = 0 ;
5727   std::string *arg2 = 0 ;
5728   int arg3 ;
5729   Dali::Property *result = 0 ;
5730
5731   arg1 = (Dali::Handle *)jarg1;
5732   if (!arg1) {
5733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5734     return 0;
5735   }
5736   if (!jarg2) {
5737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
5738     return 0;
5739   }
5740   std::string arg2_str(jarg2);
5741   arg2 = &arg2_str;
5742   arg3 = (int)jarg3;
5743   {
5744     try {
5745       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
5746     } CALL_CATCH_EXCEPTION(0);
5747   }
5748
5749   jresult = (void *)result;
5750
5751   //argout typemap for const std::string&
5752
5753   return jresult;
5754 }
5755
5756
5757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
5758   Dali::Property *arg1 = (Dali::Property *) 0 ;
5759
5760   arg1 = (Dali::Property *)jarg1;
5761   {
5762     try {
5763       delete arg1;
5764     } CALL_CATCH_EXCEPTION();
5765   }
5766
5767 }
5768
5769
5770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
5771   Dali::Property *arg1 = (Dali::Property *) 0 ;
5772   Dali::Handle *arg2 = 0 ;
5773
5774   arg1 = (Dali::Property *)jarg1;
5775   arg2 = (Dali::Handle *)jarg2;
5776   if (!arg2) {
5777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
5778     return ;
5779   }
5780   if (arg1) (arg1)->object = *arg2;
5781 }
5782
5783
5784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
5785   void * jresult ;
5786   Dali::Property *arg1 = (Dali::Property *) 0 ;
5787   Dali::Handle *result = 0 ;
5788
5789   arg1 = (Dali::Property *)jarg1;
5790   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
5797   Dali::Property *arg1 = (Dali::Property *) 0 ;
5798   Dali::Property::Index arg2 ;
5799
5800   arg1 = (Dali::Property *)jarg1;
5801   arg2 = (Dali::Property::Index)jarg2;
5802   if (arg1) (arg1)->propertyIndex = arg2;
5803 }
5804
5805
5806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
5807   int jresult ;
5808   Dali::Property *arg1 = (Dali::Property *) 0 ;
5809   Dali::Property::Index result;
5810
5811   arg1 = (Dali::Property *)jarg1;
5812   result = (Dali::Property::Index) ((arg1)->propertyIndex);
5813   jresult = result;
5814   return jresult;
5815 }
5816
5817
5818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
5819   Dali::Property *arg1 = (Dali::Property *) 0 ;
5820   int arg2 ;
5821
5822   arg1 = (Dali::Property *)jarg1;
5823   arg2 = (int)jarg2;
5824   if (arg1) (arg1)->componentIndex = arg2;
5825 }
5826
5827
5828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
5829   int jresult ;
5830   Dali::Property *arg1 = (Dali::Property *) 0 ;
5831   int result;
5832
5833   arg1 = (Dali::Property *)jarg1;
5834   result = (int) ((arg1)->componentIndex);
5835   jresult = result;
5836   return jresult;
5837 }
5838
5839
5840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
5841   void * jresult ;
5842   Dali::Property::Array *result = 0 ;
5843
5844   {
5845     try {
5846       result = (Dali::Property::Array *)new Dali::Property::Array();
5847     } CALL_CATCH_EXCEPTION(0);
5848   }
5849
5850   jresult = (void *)result;
5851   return jresult;
5852 }
5853
5854
5855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
5856   void * jresult ;
5857   Dali::Property::Array *arg1 = 0 ;
5858   Dali::Property::Array *result = 0 ;
5859
5860   arg1 = (Dali::Property::Array *)jarg1;
5861   if (!arg1) {
5862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
5863     return 0;
5864   }
5865   {
5866     try {
5867       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
5868     } CALL_CATCH_EXCEPTION(0);
5869   }
5870
5871   jresult = (void *)result;
5872   return jresult;
5873 }
5874
5875
5876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
5877   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5878
5879   arg1 = (Dali::Property::Array *)jarg1;
5880   {
5881     try {
5882       delete arg1;
5883     } CALL_CATCH_EXCEPTION();
5884   }
5885
5886 }
5887
5888
5889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
5890   unsigned long jresult ;
5891   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5892   Dali::Property::Array::SizeType result;
5893
5894   arg1 = (Dali::Property::Array *)jarg1;
5895   {
5896     try {
5897       result = ((Dali::Property::Array const *)arg1)->Size();
5898     } CALL_CATCH_EXCEPTION(0);
5899   }
5900
5901   jresult = (unsigned long)result;
5902   return jresult;
5903 }
5904
5905
5906 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
5907   unsigned long jresult ;
5908   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5909   Dali::Property::Array::SizeType result;
5910
5911   arg1 = (Dali::Property::Array *)jarg1;
5912   {
5913     try {
5914       result = ((Dali::Property::Array const *)arg1)->Count();
5915     } CALL_CATCH_EXCEPTION(0);
5916   }
5917
5918   jresult = (unsigned long)result;
5919   return jresult;
5920 }
5921
5922
5923 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
5924   bool jresult ;
5925   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5926   bool result;
5927
5928   arg1 = (Dali::Property::Array *)jarg1;
5929   {
5930     try {
5931       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
5932     } CALL_CATCH_EXCEPTION(0);
5933   }
5934
5935   jresult = result;
5936   return jresult;
5937 }
5938
5939
5940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
5941   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5942
5943   arg1 = (Dali::Property::Array *)jarg1;
5944   {
5945     try {
5946       (arg1)->Clear();
5947     } CALL_CATCH_EXCEPTION();
5948   }
5949
5950 }
5951
5952
5953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
5954   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5955   Dali::Property::Array::SizeType arg2 ;
5956
5957   arg1 = (Dali::Property::Array *)jarg1;
5958   arg2 = (Dali::Property::Array::SizeType)jarg2;
5959   {
5960     try {
5961       (arg1)->Reserve(arg2);
5962     } CALL_CATCH_EXCEPTION();
5963   }
5964
5965 }
5966
5967
5968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
5969   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5970   Dali::Property::Array::SizeType arg2 ;
5971
5972   arg1 = (Dali::Property::Array *)jarg1;
5973   arg2 = (Dali::Property::Array::SizeType)jarg2;
5974   {
5975     try {
5976       (arg1)->Resize(arg2);
5977     } CALL_CATCH_EXCEPTION();
5978   }
5979
5980 }
5981
5982
5983 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
5984   unsigned long jresult ;
5985   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
5986   Dali::Property::Array::SizeType result;
5987
5988   arg1 = (Dali::Property::Array *)jarg1;
5989   {
5990     try {
5991       result = (arg1)->Capacity();
5992     } CALL_CATCH_EXCEPTION(0);
5993   }
5994
5995   jresult = (unsigned long)result;
5996   return jresult;
5997 }
5998
5999
6000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
6001   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6002   Dali::Property::Value *arg2 = 0 ;
6003
6004   arg1 = (Dali::Property::Array *)jarg1;
6005   arg2 = (Dali::Property::Value *)jarg2;
6006   if (!arg2) {
6007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6008     return ;
6009   }
6010   {
6011     try {
6012       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
6013     } CALL_CATCH_EXCEPTION();
6014   }
6015
6016 }
6017
6018
6019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
6020   void * jresult ;
6021   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6022   Dali::Property::Value *arg2 = 0 ;
6023   Dali::Property::Array *result = 0 ;
6024
6025   arg1 = (Dali::Property::Array *)jarg1;
6026   arg2 = (Dali::Property::Value *)jarg2;
6027   if (!arg2) {
6028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6029     return 0;
6030   }
6031   {
6032     try {
6033       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
6034     } CALL_CATCH_EXCEPTION(0);
6035   }
6036
6037   jresult = (void *)result;
6038   return jresult;
6039 }
6040
6041
6042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
6043   void * jresult ;
6044   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6045   Dali::Property::Array::SizeType arg2 ;
6046   Dali::Property::Value *result = 0 ;
6047
6048   arg1 = (Dali::Property::Array *)jarg1;
6049   arg2 = (Dali::Property::Array::SizeType)jarg2;
6050   {
6051     try {
6052       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
6053     } CALL_CATCH_EXCEPTION(0);
6054   }
6055
6056   jresult = (void *)result;
6057   return jresult;
6058 }
6059
6060
6061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
6062   void * jresult ;
6063   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6064   Dali::Property::Array::SizeType arg2 ;
6065   Dali::Property::Value *result = 0 ;
6066
6067   arg1 = (Dali::Property::Array *)jarg1;
6068   arg2 = (Dali::Property::Array::SizeType)jarg2;
6069   {
6070     try {
6071       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
6072     } CALL_CATCH_EXCEPTION(0);
6073   }
6074
6075   jresult = (void *)result;
6076   return jresult;
6077 }
6078
6079
6080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
6081   void * jresult ;
6082   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
6083   Dali::Property::Array *arg2 = 0 ;
6084   Dali::Property::Array *result = 0 ;
6085
6086   arg1 = (Dali::Property::Array *)jarg1;
6087   arg2 = (Dali::Property::Array *)jarg2;
6088   if (!arg2) {
6089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
6090     return 0;
6091   }
6092   {
6093     try {
6094       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
6095     } CALL_CATCH_EXCEPTION(0);
6096   }
6097
6098   jresult = (void *)result;
6099   return jresult;
6100 }
6101
6102
6103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
6104   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6105   enum Dali::Property::Key::Type arg2 ;
6106
6107   arg1 = (Dali::Property::Key *)jarg1;
6108   arg2 = (enum Dali::Property::Key::Type)jarg2;
6109   if (arg1) (arg1)->type = arg2;
6110 }
6111
6112
6113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
6114   int jresult ;
6115   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6116   enum Dali::Property::Key::Type result;
6117
6118   arg1 = (Dali::Property::Key *)jarg1;
6119   result = (enum Dali::Property::Key::Type) ((arg1)->type);
6120   jresult = (int)result;
6121   return jresult;
6122 }
6123
6124
6125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
6126   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6127   Dali::Property::Index arg2 ;
6128
6129   arg1 = (Dali::Property::Key *)jarg1;
6130   arg2 = (Dali::Property::Index)jarg2;
6131   if (arg1) (arg1)->indexKey = arg2;
6132 }
6133
6134
6135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
6136   int jresult ;
6137   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6138   Dali::Property::Index result;
6139
6140   arg1 = (Dali::Property::Key *)jarg1;
6141   result = (Dali::Property::Index) ((arg1)->indexKey);
6142   jresult = result;
6143   return jresult;
6144 }
6145
6146
6147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
6148   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6149   std::string *arg2 = 0 ;
6150
6151   arg1 = (Dali::Property::Key *)jarg1;
6152   if (!jarg2) {
6153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6154     return ;
6155   }
6156   std::string arg2_str(jarg2);
6157   arg2 = &arg2_str;
6158   if (arg1) (arg1)->stringKey = *arg2;
6159
6160   //argout typemap for const std::string&
6161
6162 }
6163
6164
6165 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
6166   char * jresult ;
6167   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6168   std::string *result = 0 ;
6169
6170   arg1 = (Dali::Property::Key *)jarg1;
6171   result = (std::string *) & ((arg1)->stringKey);
6172   jresult = SWIG_csharp_string_callback(result->c_str());
6173   return jresult;
6174 }
6175
6176
6177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
6178   void * jresult ;
6179   std::string *arg1 = 0 ;
6180   Dali::Property::Key *result = 0 ;
6181
6182   if (!jarg1) {
6183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6184     return 0;
6185   }
6186   std::string arg1_str(jarg1);
6187   arg1 = &arg1_str;
6188   {
6189     try {
6190       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
6191     } CALL_CATCH_EXCEPTION(0);
6192   }
6193
6194   jresult = (void *)result;
6195
6196   //argout typemap for const std::string&
6197
6198   return jresult;
6199 }
6200
6201
6202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
6203   void * jresult ;
6204   Dali::Property::Index arg1 ;
6205   Dali::Property::Key *result = 0 ;
6206
6207   arg1 = (Dali::Property::Index)jarg1;
6208   {
6209     try {
6210       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
6211     } CALL_CATCH_EXCEPTION(0);
6212   }
6213
6214   jresult = (void *)result;
6215   return jresult;
6216 }
6217
6218
6219 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
6220   bool jresult ;
6221   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6222   std::string *arg2 = 0 ;
6223   bool result;
6224
6225   arg1 = (Dali::Property::Key *)jarg1;
6226   if (!jarg2) {
6227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6228     return 0;
6229   }
6230   std::string arg2_str(jarg2);
6231   arg2 = &arg2_str;
6232   {
6233     try {
6234       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
6235     } CALL_CATCH_EXCEPTION(0);
6236   }
6237
6238   jresult = result;
6239
6240   //argout typemap for const std::string&
6241
6242   return jresult;
6243 }
6244
6245
6246 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
6247   bool jresult ;
6248   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6249   Dali::Property::Index arg2 ;
6250   bool result;
6251
6252   arg1 = (Dali::Property::Key *)jarg1;
6253   arg2 = (Dali::Property::Index)jarg2;
6254   {
6255     try {
6256       result = (bool)(arg1)->operator ==(arg2);
6257     } CALL_CATCH_EXCEPTION(0);
6258   }
6259
6260   jresult = result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
6266   bool jresult ;
6267   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6268   Dali::Property::Key *arg2 = 0 ;
6269   bool result;
6270
6271   arg1 = (Dali::Property::Key *)jarg1;
6272   arg2 = (Dali::Property::Key *)jarg2;
6273   if (!arg2) {
6274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
6275     return 0;
6276   }
6277   {
6278     try {
6279       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
6280     } CALL_CATCH_EXCEPTION(0);
6281   }
6282
6283   jresult = result;
6284   return jresult;
6285 }
6286
6287
6288 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
6289   bool jresult ;
6290   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6291   std::string *arg2 = 0 ;
6292   bool result;
6293
6294   arg1 = (Dali::Property::Key *)jarg1;
6295   if (!jarg2) {
6296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6297     return 0;
6298   }
6299   std::string arg2_str(jarg2);
6300   arg2 = &arg2_str;
6301   {
6302     try {
6303       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
6304     } CALL_CATCH_EXCEPTION(0);
6305   }
6306
6307   jresult = result;
6308
6309   //argout typemap for const std::string&
6310
6311   return jresult;
6312 }
6313
6314
6315 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
6316   bool jresult ;
6317   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6318   Dali::Property::Index arg2 ;
6319   bool result;
6320
6321   arg1 = (Dali::Property::Key *)jarg1;
6322   arg2 = (Dali::Property::Index)jarg2;
6323   {
6324     try {
6325       result = (bool)(arg1)->operator !=(arg2);
6326     } CALL_CATCH_EXCEPTION(0);
6327   }
6328
6329   jresult = result;
6330   return jresult;
6331 }
6332
6333
6334 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
6335   bool jresult ;
6336   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6337   Dali::Property::Key *arg2 = 0 ;
6338   bool result;
6339
6340   arg1 = (Dali::Property::Key *)jarg1;
6341   arg2 = (Dali::Property::Key *)jarg2;
6342   if (!arg2) {
6343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
6344     return 0;
6345   }
6346   {
6347     try {
6348       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
6349     } CALL_CATCH_EXCEPTION(0);
6350   }
6351
6352   jresult = result;
6353   return jresult;
6354 }
6355
6356
6357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
6358   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
6359
6360   arg1 = (Dali::Property::Key *)jarg1;
6361   {
6362     try {
6363       delete arg1;
6364     } CALL_CATCH_EXCEPTION();
6365   }
6366
6367 }
6368
6369
6370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
6371   void * jresult ;
6372   Dali::Property::Map *result = 0 ;
6373
6374   {
6375     try {
6376       result = (Dali::Property::Map *)new Dali::Property::Map();
6377     } CALL_CATCH_EXCEPTION(0);
6378   }
6379
6380   jresult = (void *)result;
6381   return jresult;
6382 }
6383
6384
6385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
6386   void * jresult ;
6387   Dali::Property::Map *arg1 = 0 ;
6388   Dali::Property::Map *result = 0 ;
6389
6390   arg1 = (Dali::Property::Map *)jarg1;
6391   if (!arg1) {
6392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
6393     return 0;
6394   }
6395   {
6396     try {
6397       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
6398     } CALL_CATCH_EXCEPTION(0);
6399   }
6400
6401   jresult = (void *)result;
6402   return jresult;
6403 }
6404
6405
6406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
6407   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6408
6409   arg1 = (Dali::Property::Map *)jarg1;
6410   {
6411     try {
6412       delete arg1;
6413     } CALL_CATCH_EXCEPTION();
6414   }
6415
6416 }
6417
6418
6419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
6420   unsigned long jresult ;
6421   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6422   Dali::Property::Map::SizeType result;
6423
6424   arg1 = (Dali::Property::Map *)jarg1;
6425   {
6426     try {
6427       result = ((Dali::Property::Map const *)arg1)->Count();
6428     } CALL_CATCH_EXCEPTION(0);
6429   }
6430
6431   jresult = (unsigned long)result;
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
6437   bool jresult ;
6438   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6439   bool result;
6440
6441   arg1 = (Dali::Property::Map *)jarg1;
6442   {
6443     try {
6444       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
6445     } CALL_CATCH_EXCEPTION(0);
6446   }
6447
6448   jresult = result;
6449   return jresult;
6450 }
6451
6452
6453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
6454   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6455   char *arg2 = (char *) 0 ;
6456   Dali::Property::Value *arg3 = 0 ;
6457
6458   arg1 = (Dali::Property::Map *)jarg1;
6459   arg2 = (char *)jarg2;
6460   arg3 = (Dali::Property::Value *)jarg3;
6461   if (!arg3) {
6462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6463     return ;
6464   }
6465   {
6466     try {
6467       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
6468     } CALL_CATCH_EXCEPTION();
6469   }
6470
6471 }
6472
6473
6474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_0(void * jarg1, const char * jarg2, int jarg3) {
6475   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6476
6477   arg1 = (Dali::Property::Map *)jarg1;
6478   {
6479     try {
6480       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6481     } CALL_CATCH_EXCEPTION();
6482   }
6483
6484 }
6485
6486
6487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_0(void * jarg1, const char * jarg2, bool jarg3) {
6488   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6489
6490   arg1 = (Dali::Property::Map *)jarg1;
6491   {
6492     try {
6493       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6494     } CALL_CATCH_EXCEPTION();
6495   }
6496
6497 }
6498
6499
6500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_0(void * jarg1, const char * jarg2, float jarg3) {
6501   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6502
6503   arg1 = (Dali::Property::Map *)jarg1;
6504   {
6505     try {
6506       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6507     } CALL_CATCH_EXCEPTION();
6508   }
6509
6510 }
6511
6512
6513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_0(void * jarg1, const char * jarg2, const char * jarg3) {
6514   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6515
6516   arg1 = (Dali::Property::Map *)jarg1;
6517   {
6518     try {
6519       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(jarg3));
6520     } CALL_CATCH_EXCEPTION();
6521   }
6522
6523 }
6524
6525
6526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4) {
6527   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6528
6529   arg1 = (Dali::Property::Map *)jarg1;
6530   {
6531     try {
6532       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
6533     } CALL_CATCH_EXCEPTION();
6534   }
6535
6536 }
6537
6538
6539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5) {
6540   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6541
6542   arg1 = (Dali::Property::Map *)jarg1;
6543   {
6544     try {
6545       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
6546     } CALL_CATCH_EXCEPTION();
6547   }
6548
6549 }
6550
6551
6552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_0(void * jarg1, const char * jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
6553   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6554
6555   arg1 = (Dali::Property::Map *)jarg1;
6556   {
6557     try {
6558       (arg1)->Insert(jarg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
6559     } CALL_CATCH_EXCEPTION();
6560   }
6561
6562 }
6563
6564
6565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
6566   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6567   Dali::Property::Index arg2 ;
6568   Dali::Property::Value *arg3 = 0 ;
6569
6570   arg1 = (Dali::Property::Map *)jarg1;
6571   arg2 = (Dali::Property::Index)jarg2;
6572   arg3 = (Dali::Property::Value *)jarg3;
6573   if (!arg3) {
6574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6575     return ;
6576   }
6577   {
6578     try {
6579       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
6580     } CALL_CATCH_EXCEPTION();
6581   }
6582
6583 }
6584
6585
6586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Int__SWIG_2(void * jarg1, int jarg2, int jarg3) {
6587   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6588   Dali::Property::Index arg2 ;
6589
6590   arg1 = (Dali::Property::Map *)jarg1;
6591   arg2 = (Dali::Property::Index)jarg2;
6592   {
6593     try {
6594       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6595     } CALL_CATCH_EXCEPTION();
6596   }
6597
6598 }
6599
6600
6601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Bool__SWIG_2(void * jarg1, int jarg2, bool jarg3) {
6602   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6603   Dali::Property::Index arg2 ;
6604
6605   arg1 = (Dali::Property::Map *)jarg1;
6606   arg2 = (Dali::Property::Index)jarg2;
6607   {
6608     try {
6609       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6610     } CALL_CATCH_EXCEPTION();
6611   }
6612
6613 }
6614
6615
6616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Float__SWIG_2(void * jarg1, int jarg2, float jarg3) {
6617   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6618   Dali::Property::Index arg2 ;
6619
6620   arg1 = (Dali::Property::Map *)jarg1;
6621   arg2 = (Dali::Property::Index)jarg2;
6622   {
6623     try {
6624       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6625     } CALL_CATCH_EXCEPTION();
6626   }
6627
6628 }
6629
6630
6631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_String__SWIG_2(void * jarg1, int jarg2, char * jarg3) {
6632   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6633   Dali::Property::Index arg2 ;
6634
6635   arg1 = (Dali::Property::Map *)jarg1;
6636   arg2 = (Dali::Property::Index)jarg2;
6637   {
6638     try {
6639       (arg1)->Insert(arg2,(Dali::Property::Value const &)(jarg3));
6640     } CALL_CATCH_EXCEPTION();
6641   }
6642
6643 }
6644
6645
6646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector2__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4) {
6647   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6648   Dali::Property::Index arg2 ;
6649
6650   arg1 = (Dali::Property::Map *)jarg1;
6651   arg2 = (Dali::Property::Index)jarg2;
6652   {
6653     try {
6654       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4)));
6655     } CALL_CATCH_EXCEPTION();
6656   }
6657
6658 }
6659
6660
6661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector3__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5) {
6662   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6663   Dali::Property::Index arg2 ;
6664
6665   arg1 = (Dali::Property::Map *)jarg1;
6666   arg2 = (Dali::Property::Index)jarg2;
6667   {
6668     try {
6669       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector3(jarg3, jarg4, jarg5)));
6670     } CALL_CATCH_EXCEPTION();
6671   }
6672
6673 }
6674
6675
6676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert_Vector4__SWIG_2(void * jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
6677   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6678   Dali::Property::Index arg2 ;
6679
6680   arg1 = (Dali::Property::Map *)jarg1;
6681   arg2 = (Dali::Property::Index)jarg2;
6682   {
6683     try {
6684       (arg1)->Insert(arg2,(Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6)));
6685     } CALL_CATCH_EXCEPTION();
6686   }
6687
6688 }
6689
6690
6691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
6692   void * jresult ;
6693   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6694   char *arg2 = (char *) 0 ;
6695   Dali::Property::Value *arg3 = 0 ;
6696   Dali::Property::Map *result = 0 ;
6697
6698   arg1 = (Dali::Property::Map *)jarg1;
6699   arg2 = (char *)jarg2;
6700   arg3 = (Dali::Property::Value *)jarg3;
6701   if (!arg3) {
6702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6703     return 0;
6704   }
6705   {
6706     try {
6707       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
6708     } CALL_CATCH_EXCEPTION(0);
6709   }
6710
6711   jresult = (void *)result;
6712   return jresult;
6713 }
6714
6715
6716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
6717   void * jresult ;
6718   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6719   Dali::Property::Index arg2 ;
6720   Dali::Property::Value *arg3 = 0 ;
6721   Dali::Property::Map *result = 0 ;
6722
6723   arg1 = (Dali::Property::Map *)jarg1;
6724   arg2 = (Dali::Property::Index)jarg2;
6725   arg3 = (Dali::Property::Value *)jarg3;
6726   if (!arg3) {
6727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6728     return 0;
6729   }
6730   {
6731     try {
6732       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
6733     } CALL_CATCH_EXCEPTION(0);
6734   }
6735
6736   jresult = (void *)result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
6742   void * jresult ;
6743   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6744   Dali::Property::Map::SizeType arg2 ;
6745   Dali::Property::Value *result = 0 ;
6746
6747   arg1 = (Dali::Property::Map *)jarg1;
6748   arg2 = (Dali::Property::Map::SizeType)jarg2;
6749   {
6750     try {
6751       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
6752     } CALL_CATCH_EXCEPTION(0);
6753   }
6754
6755   jresult = (void *)result;
6756   return jresult;
6757 }
6758
6759
6760 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
6761   char * jresult ;
6762   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6763   Dali::Property::Map::SizeType arg2 ;
6764   std::string *result = 0 ;
6765
6766   arg1 = (Dali::Property::Map *)jarg1;
6767   arg2 = (Dali::Property::Map::SizeType)jarg2;
6768   {
6769     try {
6770       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
6771     } CALL_CATCH_EXCEPTION(0);
6772   }
6773
6774   jresult = SWIG_csharp_string_callback(result->c_str());
6775   return jresult;
6776 }
6777
6778
6779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
6780   void * jresult ;
6781   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6782   Dali::Property::Map::SizeType arg2 ;
6783   SwigValueWrapper< Dali::Property::Key > result;
6784
6785   arg1 = (Dali::Property::Map *)jarg1;
6786   arg2 = (Dali::Property::Map::SizeType)jarg2;
6787   {
6788     try {
6789       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
6790     } CALL_CATCH_EXCEPTION(0);
6791   }
6792
6793   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
6794   return jresult;
6795 }
6796
6797
6798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
6799   void * jresult ;
6800   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6801   Dali::Property::Map::SizeType arg2 ;
6802   StringValuePair *result = 0 ;
6803
6804   arg1 = (Dali::Property::Map *)jarg1;
6805   arg2 = (Dali::Property::Map::SizeType)jarg2;
6806   {
6807     try {
6808       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
6809     } CALL_CATCH_EXCEPTION(0);
6810   }
6811
6812   jresult = (void *)result;
6813   return jresult;
6814 }
6815
6816
6817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
6818   void * jresult ;
6819   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6820   char *arg2 = (char *) 0 ;
6821   Dali::Property::Value *result = 0 ;
6822
6823   arg1 = (Dali::Property::Map *)jarg1;
6824   arg2 = (char *)jarg2;
6825   {
6826     try {
6827       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
6828     } CALL_CATCH_EXCEPTION(0);
6829   }
6830
6831   jresult = (void *)result;
6832   return jresult;
6833 }
6834
6835
6836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
6837   void * jresult ;
6838   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6839   Dali::Property::Index arg2 ;
6840   Dali::Property::Value *result = 0 ;
6841
6842   arg1 = (Dali::Property::Map *)jarg1;
6843   arg2 = (Dali::Property::Index)jarg2;
6844   {
6845     try {
6846       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
6847     } CALL_CATCH_EXCEPTION(0);
6848   }
6849
6850   jresult = (void *)result;
6851   return jresult;
6852 }
6853
6854
6855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
6856   void * jresult ;
6857   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6858   Dali::Property::Index arg2 ;
6859   std::string *arg3 = 0 ;
6860   Dali::Property::Value *result = 0 ;
6861
6862   arg1 = (Dali::Property::Map *)jarg1;
6863   arg2 = (Dali::Property::Index)jarg2;
6864   if (!jarg3) {
6865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6866     return 0;
6867   }
6868   std::string arg3_str(jarg3);
6869   arg3 = &arg3_str;
6870   {
6871     try {
6872       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
6873     } CALL_CATCH_EXCEPTION(0);
6874   }
6875
6876   jresult = (void *)result;
6877
6878   //argout typemap for const std::string&
6879
6880   return jresult;
6881 }
6882
6883
6884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
6885   void * jresult ;
6886   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6887   std::string *arg2 = 0 ;
6888   Dali::Property::Type arg3 ;
6889   Dali::Property::Value *result = 0 ;
6890
6891   arg1 = (Dali::Property::Map *)jarg1;
6892   if (!jarg2) {
6893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6894     return 0;
6895   }
6896   std::string arg2_str(jarg2);
6897   arg2 = &arg2_str;
6898   arg3 = (Dali::Property::Type)jarg3;
6899   {
6900     try {
6901       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
6902     } CALL_CATCH_EXCEPTION(0);
6903   }
6904
6905   jresult = (void *)result;
6906
6907   //argout typemap for const std::string&
6908
6909   return jresult;
6910 }
6911
6912
6913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
6914   void * jresult ;
6915   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6916   Dali::Property::Index arg2 ;
6917   Dali::Property::Type arg3 ;
6918   Dali::Property::Value *result = 0 ;
6919
6920   arg1 = (Dali::Property::Map *)jarg1;
6921   arg2 = (Dali::Property::Index)jarg2;
6922   arg3 = (Dali::Property::Type)jarg3;
6923   {
6924     try {
6925       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
6926     } CALL_CATCH_EXCEPTION(0);
6927   }
6928
6929   jresult = (void *)result;
6930   return jresult;
6931 }
6932
6933
6934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
6935   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6936
6937   arg1 = (Dali::Property::Map *)jarg1;
6938   {
6939     try {
6940       (arg1)->Clear();
6941     } CALL_CATCH_EXCEPTION();
6942   }
6943
6944 }
6945
6946
6947 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
6948   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
6949   Dali::Property::Index intKey = (Dali::Property::Index)key;
6950   bool isRemoved = false;
6951   {
6952     try {
6953       isRemoved = propertyMap->Remove(intKey);
6954     } CALL_CATCH_EXCEPTION(0);
6955   }
6956   return isRemoved;
6957 }
6958
6959
6960 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
6961   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
6962   std::string strKey(key);
6963   bool isRemoved = false;
6964   {
6965     try {
6966       isRemoved = propertyMap->Remove(strKey);
6967     } CALL_CATCH_EXCEPTION(0);
6968   }
6969   return isRemoved;
6970 }
6971
6972
6973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
6974   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6975   Dali::Property::Map *arg2 = 0 ;
6976
6977   arg1 = (Dali::Property::Map *)jarg1;
6978   arg2 = (Dali::Property::Map *)jarg2;
6979   if (!arg2) {
6980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
6981     return ;
6982   }
6983   {
6984     try {
6985       (arg1)->Merge((Dali::Property::Map const &)*arg2);
6986     } CALL_CATCH_EXCEPTION();
6987   }
6988
6989 }
6990
6991
6992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
6993   void * jresult ;
6994   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6995   std::string *arg2 = 0 ;
6996   Dali::Property::Value *result = 0 ;
6997
6998   arg1 = (Dali::Property::Map *)jarg1;
6999   if (!jarg2) {
7000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7001     return 0;
7002   }
7003   std::string arg2_str(jarg2);
7004   arg2 = &arg2_str;
7005   {
7006     try {
7007       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
7008     } CALL_CATCH_EXCEPTION(0);
7009   }
7010
7011   jresult = (void *)result;
7012
7013   //argout typemap for const std::string&
7014
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
7020   void * jresult ;
7021   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
7022   Dali::Property::Index arg2 ;
7023   Dali::Property::Value *result = 0 ;
7024
7025   arg1 = (Dali::Property::Map *)jarg1;
7026   arg2 = (Dali::Property::Index)jarg2;
7027   {
7028     try {
7029       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
7030     } CALL_CATCH_EXCEPTION(0);
7031   }
7032
7033   jresult = (void *)result;
7034   return jresult;
7035 }
7036
7037
7038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
7039   void * jresult ;
7040   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
7041   Dali::Property::Map *arg2 = 0 ;
7042   Dali::Property::Map *result = 0 ;
7043
7044   arg1 = (Dali::Property::Map *)jarg1;
7045   arg2 = (Dali::Property::Map *)jarg2;
7046   if (!arg2) {
7047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
7048     return 0;
7049   }
7050   {
7051     try {
7052       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
7053     } CALL_CATCH_EXCEPTION(0);
7054   }
7055
7056   jresult = (void *)result;
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
7062
7063   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7064
7065   if (!jarg2) {
7066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7067     return;
7068   }
7069   std::string arg2_str(jarg2);
7070   std::string* arg2 = &arg2_str;
7071
7072   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
7073
7074   {
7075     try {
7076       arg1->operator[]((std::string const &)*arg2) = *arg3;
7077     } CALL_CATCH_EXCEPTION();
7078   }
7079 }
7080
7081
7082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_IntValue(void* jarg1, const char* jarg2, int jarg3) {
7083
7084   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7085
7086   if (!jarg2) {
7087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7088     return;
7089   }
7090   Dali::Property::Index arg3 = (Dali::Property::Index)jarg3;
7091
7092   {
7093     try {
7094       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(arg3);
7095     } CALL_CATCH_EXCEPTION();
7096   }
7097 }
7098
7099
7100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_BoolValue(void* jarg1, const char* jarg2, bool jarg3) {
7101
7102   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7103
7104   if (!jarg2) {
7105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7106     return;
7107   }
7108
7109   {
7110     try {
7111       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
7112     } CALL_CATCH_EXCEPTION();
7113   }
7114 }
7115
7116
7117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_FloatValue(void* jarg1, const char* jarg2, float jarg3) {
7118
7119   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7120
7121   if (!jarg2) {
7122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7123     return;
7124   }
7125
7126   {
7127     try {
7128       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
7129     } CALL_CATCH_EXCEPTION();
7130   }
7131 }
7132
7133
7134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_StringValue(void* jarg1, const char* jarg2, const char* jarg3) {
7135
7136   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7137
7138   if (!jarg2) {
7139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7140     return;
7141   }
7142
7143   {
7144     try {
7145       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(jarg3);
7146     } CALL_CATCH_EXCEPTION();
7147   }
7148 }
7149
7150
7151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector2(void* jarg1, const char* jarg2, float jarg3, float jarg4) {
7152
7153   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7154
7155   if (!jarg2) {
7156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7157     return;
7158   }
7159
7160   {
7161     try {
7162       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
7163     } CALL_CATCH_EXCEPTION();
7164   }
7165 }
7166
7167
7168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Vector4(void* jarg1, const char* jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
7169
7170   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7171
7172   if (!jarg2) {
7173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7174     return;
7175   }
7176
7177   {
7178     try {
7179       arg1->operator[](std::string_view(jarg2)) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
7180     } CALL_CATCH_EXCEPTION();
7181   }
7182 }
7183
7184
7185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey_Rect(void* jarg1, char* jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
7186
7187   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7188
7189   if (!jarg2) {
7190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7191     return;
7192   }
7193
7194   {
7195     try {
7196       arg1->operator[](std::string(jarg2)) = (Dali::Property::Value const &)(Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6));
7197     } CALL_CATCH_EXCEPTION();
7198   }
7199 }
7200
7201
7202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
7203
7204   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7205   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7206   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
7207
7208   {
7209     try {
7210       arg1->operator[](arg2) = *arg3;
7211     } CALL_CATCH_EXCEPTION();
7212   }
7213 }
7214
7215
7216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_IntValue(void* jarg1, int jarg2, int jarg3) {
7217
7218   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7219   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7220   Dali::Property::Index arg3 = (Dali::Property::Index)jarg3;
7221
7222   {
7223     try {
7224       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7225     } CALL_CATCH_EXCEPTION();
7226   }
7227 }
7228
7229
7230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_BoolValue(void* jarg1, int jarg2, bool jarg3) {
7231
7232   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7233   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7234   bool arg3 = (bool)jarg3;
7235
7236   {
7237     try {
7238       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7239     } CALL_CATCH_EXCEPTION();
7240   }
7241 }
7242
7243
7244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_FloatValue(void* jarg1, int jarg2, float jarg3) {
7245
7246   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7247   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7248   float arg3 = (float)jarg3;
7249
7250   {
7251     try {
7252       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7253     } CALL_CATCH_EXCEPTION();
7254   }
7255 }
7256
7257
7258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_StringValue(void* jarg1, int jarg2, char* jarg3) {
7259
7260   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7261   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7262   char *arg3 = (char *)jarg3;
7263
7264   {
7265     try {
7266       arg1->operator[](arg2) = (Dali::Property::Value const &)(arg3);
7267     } CALL_CATCH_EXCEPTION();
7268   }
7269 }
7270
7271
7272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector2(void* jarg1, int jarg2, float jarg3, float jarg4) {
7273
7274   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7275   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7276
7277   {
7278     try {
7279       arg1->operator[](arg2) = (Dali::Property::Value const &)(Dali::Vector2(jarg3, jarg4));
7280     } CALL_CATCH_EXCEPTION();
7281   }
7282 }
7283
7284
7285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Vector4(void* jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
7286
7287   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7288   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7289
7290   {
7291     try {
7292       arg1->operator[](arg2) = (Dali::Property::Value const &)(Dali::Vector4(jarg3, jarg4, jarg5, jarg6));
7293     } CALL_CATCH_EXCEPTION();
7294   }
7295 }
7296
7297
7298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey_Rect(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
7299
7300   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
7301   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
7302   Dali::Rect< int > *arg3 = 0 ;
7303
7304   arg3 = (Dali::Rect< int > *)new Dali::Rect< int >(jarg3, jarg4, jarg5, jarg6);
7305
7306   {
7307     try {
7308       arg1->operator[](arg2) = (Dali::Property::Value const &)(*arg3);
7309     } CALL_CATCH_EXCEPTION();
7310   }
7311 }
7312
7313
7314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
7315   void * jresult ;
7316   Dali::Property::Value *result = 0 ;
7317
7318   {
7319     try {
7320       result = (Dali::Property::Value *)new Dali::Property::Value();
7321     } CALL_CATCH_EXCEPTION(0);
7322   }
7323
7324   jresult = (void *)result;
7325   return jresult;
7326 }
7327
7328
7329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
7330   void * jresult ;
7331   bool arg1 ;
7332   Dali::Property::Value *result = 0 ;
7333
7334   arg1 = jarg1 ? true : false;
7335   {
7336     try {
7337       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7338     } CALL_CATCH_EXCEPTION(0);
7339   }
7340
7341   jresult = (void *)result;
7342   return jresult;
7343 }
7344
7345
7346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
7347   void * jresult ;
7348   int arg1 ;
7349   Dali::Property::Value *result = 0 ;
7350
7351   arg1 = (int)jarg1;
7352   {
7353     try {
7354       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7355     } CALL_CATCH_EXCEPTION(0);
7356   }
7357
7358   jresult = (void *)result;
7359   return jresult;
7360 }
7361
7362
7363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
7364   void * jresult ;
7365   float arg1 ;
7366   Dali::Property::Value *result = 0 ;
7367
7368   arg1 = (float)jarg1;
7369   {
7370     try {
7371       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7372     } CALL_CATCH_EXCEPTION(0);
7373   }
7374
7375   jresult = (void *)result;
7376   return jresult;
7377 }
7378
7379
7380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
7381   void * jresult ;
7382   Dali::Vector2 *arg1 = 0 ;
7383   Dali::Property::Value *result = 0 ;
7384
7385   arg1 = (Dali::Vector2 *)jarg1;
7386   if (!arg1) {
7387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7388     return 0;
7389   }
7390   {
7391     try {
7392       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
7393     } CALL_CATCH_EXCEPTION(0);
7394   }
7395
7396   jresult = (void *)result;
7397   return jresult;
7398 }
7399
7400
7401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
7402   void * jresult ;
7403   Dali::Vector3 *arg1 = 0 ;
7404   Dali::Property::Value *result = 0 ;
7405
7406   arg1 = (Dali::Vector3 *)jarg1;
7407   if (!arg1) {
7408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7409     return 0;
7410   }
7411   {
7412     try {
7413       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
7414     } CALL_CATCH_EXCEPTION(0);
7415   }
7416
7417   jresult = (void *)result;
7418   return jresult;
7419 }
7420
7421
7422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
7423   void * jresult ;
7424   Dali::Vector4 *arg1 = 0 ;
7425   Dali::Property::Value *result = 0 ;
7426
7427   arg1 = (Dali::Vector4 *)jarg1;
7428   if (!arg1) {
7429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7430     return 0;
7431   }
7432   {
7433     try {
7434       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
7435     } CALL_CATCH_EXCEPTION(0);
7436   }
7437
7438   jresult = (void *)result;
7439   return jresult;
7440 }
7441
7442
7443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
7444   void * jresult ;
7445   Dali::Matrix3 *arg1 = 0 ;
7446   Dali::Property::Value *result = 0 ;
7447
7448   arg1 = (Dali::Matrix3 *)jarg1;
7449   if (!arg1) {
7450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
7451     return 0;
7452   }
7453   {
7454     try {
7455       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
7456     } CALL_CATCH_EXCEPTION(0);
7457   }
7458
7459   jresult = (void *)result;
7460   return jresult;
7461 }
7462
7463
7464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
7465   void * jresult ;
7466   Dali::Matrix *arg1 = 0 ;
7467   Dali::Property::Value *result = 0 ;
7468
7469   arg1 = (Dali::Matrix *)jarg1;
7470   if (!arg1) {
7471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7472     return 0;
7473   }
7474   {
7475     try {
7476       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
7477     } CALL_CATCH_EXCEPTION(0);
7478   }
7479
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
7486   void * jresult ;
7487   Dali::Rect< int > *arg1 = 0 ;
7488   Dali::Property::Value *result = 0 ;
7489
7490   arg1 = (Dali::Rect< int > *)jarg1;
7491   if (!arg1) {
7492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
7493     return 0;
7494   }
7495   {
7496     try {
7497       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
7498     } CALL_CATCH_EXCEPTION(0);
7499   }
7500
7501   jresult = (void *)result;
7502   return jresult;
7503 }
7504
7505
7506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
7507   void * jresult ;
7508   Dali::AngleAxis *arg1 = 0 ;
7509   Dali::Property::Value *result = 0 ;
7510
7511   arg1 = (Dali::AngleAxis *)jarg1;
7512   if (!arg1) {
7513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
7514     return 0;
7515   }
7516   {
7517     try {
7518       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
7519     } CALL_CATCH_EXCEPTION(0);
7520   }
7521
7522   jresult = (void *)result;
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
7528   void * jresult ;
7529   Dali::Quaternion *arg1 = 0 ;
7530   Dali::Property::Value *result = 0 ;
7531
7532   arg1 = (Dali::Quaternion *)jarg1;
7533   if (!arg1) {
7534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7535     return 0;
7536   }
7537   {
7538     try {
7539       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
7540     } CALL_CATCH_EXCEPTION(0);
7541   }
7542
7543   jresult = (void *)result;
7544   return jresult;
7545 }
7546
7547
7548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
7549   void * jresult ;
7550   std::string *arg1 = 0 ;
7551   Dali::Property::Value *result = 0 ;
7552
7553   if (!jarg1) {
7554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7555     return 0;
7556   }
7557   std::string arg1_str(jarg1);
7558   arg1 = &arg1_str;
7559   {
7560     try {
7561       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
7562     } CALL_CATCH_EXCEPTION(0);
7563   }
7564
7565   jresult = (void *)result;
7566
7567   //argout typemap for const std::string&
7568
7569   return jresult;
7570 }
7571
7572
7573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
7574   void * jresult ;
7575   Dali::Property::Array *arg1 = 0 ;
7576   Dali::Property::Value *result = 0 ;
7577
7578   arg1 = (Dali::Property::Array *)jarg1;
7579   if (!arg1) {
7580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
7581     return 0;
7582   }
7583   {
7584     try {
7585       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
7586     } CALL_CATCH_EXCEPTION(0);
7587   }
7588
7589   jresult = (void *)result;
7590   return jresult;
7591 }
7592
7593
7594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
7595   void * jresult ;
7596   Dali::Property::Map *arg1 = 0 ;
7597   Dali::Property::Value *result = 0 ;
7598
7599   arg1 = (Dali::Property::Map *)jarg1;
7600   if (!arg1) {
7601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
7602     return 0;
7603   }
7604   {
7605     try {
7606       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
7607     } CALL_CATCH_EXCEPTION(0);
7608   }
7609
7610   jresult = (void *)result;
7611   return jresult;
7612 }
7613
7614
7615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
7616   void * jresult ;
7617   Extents *arg1 = 0 ;
7618   Dali::Property::Value *result = 0 ;
7619
7620   arg1 = (Extents *)jarg1;
7621   if (!arg1) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
7623     return 0;
7624   }
7625   {
7626     try {
7627       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
7628     } CALL_CATCH_EXCEPTION(0);
7629   }
7630
7631   jresult = (void*) result;
7632   return jresult;
7633 }
7634
7635
7636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
7637   void * jresult ;
7638   Dali::Property::Type arg1 ;
7639   Dali::Property::Value *result = 0 ;
7640
7641   arg1 = (Dali::Property::Type)jarg1;
7642   {
7643     try {
7644       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7645     } CALL_CATCH_EXCEPTION(0);
7646   }
7647
7648   jresult = (void *)result;
7649   return jresult;
7650 }
7651
7652
7653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
7654   void * jresult ;
7655   Dali::Property::Value *arg1 = 0 ;
7656   Dali::Property::Value *result = 0 ;
7657
7658   arg1 = (Dali::Property::Value *)jarg1;
7659   if (!arg1) {
7660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7661     return 0;
7662   }
7663   {
7664     try {
7665       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
7666     } CALL_CATCH_EXCEPTION(0);
7667   }
7668
7669   jresult = (void *)result;
7670   return jresult;
7671 }
7672
7673
7674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
7675   void * jresult ;
7676   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7677   Dali::Property::Value *arg2 = 0 ;
7678   Dali::Property::Value *result = 0 ;
7679
7680   arg1 = (Dali::Property::Value *)jarg1;
7681   arg2 = (Dali::Property::Value *)jarg2;
7682   if (!arg2) {
7683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7684     return 0;
7685   }
7686   {
7687     try {
7688       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
7689     } CALL_CATCH_EXCEPTION(0);
7690   }
7691
7692   jresult = (void *)result;
7693   return jresult;
7694 }
7695
7696
7697 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
7698   bool jresult;
7699   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7700   Dali::Property::Value *arg2 = 0 ;
7701   bool result;
7702
7703   arg1 = (Dali::Property::Value *)jarg1;
7704   arg2 = (Dali::Property::Value *)jarg2;
7705   if (!arg2) {
7706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7707     return 0;
7708   }
7709   {
7710     try {
7711       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
7712     } CALL_CATCH_EXCEPTION(0);
7713   }
7714
7715   jresult = result;
7716   return jresult;
7717 }
7718
7719 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
7720   bool jresult;
7721   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7722   Dali::Property::Value *arg2 = 0 ;
7723   bool result;
7724
7725   arg1 = (Dali::Property::Value *)jarg1;
7726   arg2 = (Dali::Property::Value *)jarg2;
7727   if (!arg2) {
7728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7729     return 0;
7730   }
7731   {
7732     try {
7733       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
7734     } CALL_CATCH_EXCEPTION(0);
7735   }
7736
7737   jresult = result;
7738   return jresult;
7739 }
7740
7741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
7742   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7743
7744   arg1 = (Dali::Property::Value *)jarg1;
7745   {
7746     try {
7747       delete arg1;
7748     } CALL_CATCH_EXCEPTION();
7749   }
7750
7751 }
7752
7753
7754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
7755   int jresult ;
7756   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7757   Dali::Property::Type result;
7758
7759   arg1 = (Dali::Property::Value *)jarg1;
7760   {
7761     try {
7762       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
7763     } CALL_CATCH_EXCEPTION(0);
7764   }
7765
7766   jresult = (int)result;
7767   return jresult;
7768 }
7769
7770
7771 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
7772   bool jresult ;
7773   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7774   bool *arg2 = 0 ;
7775   bool result;
7776
7777   arg1 = (Dali::Property::Value *)jarg1;
7778   arg2 = (bool *)jarg2;
7779   {
7780     try {
7781       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7782     } CALL_CATCH_EXCEPTION(0);
7783   }
7784
7785   jresult = result;
7786   return jresult;
7787 }
7788
7789
7790 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
7791   bool jresult ;
7792   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7793   float *arg2 = 0 ;
7794   bool result;
7795
7796   arg1 = (Dali::Property::Value *)jarg1;
7797   arg2 = (float *)jarg2;
7798   {
7799     try {
7800       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7801     } CALL_CATCH_EXCEPTION(0);
7802   }
7803
7804   jresult = result;
7805   return jresult;
7806 }
7807
7808
7809 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
7810   bool jresult ;
7811   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7812   int *arg2 = 0 ;
7813   bool result;
7814
7815   arg1 = (Dali::Property::Value *)jarg1;
7816   arg2 = (int *)jarg2;
7817   {
7818     try {
7819       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7820     } CALL_CATCH_EXCEPTION(0);
7821   }
7822
7823   jresult = result;
7824   return jresult;
7825 }
7826
7827
7828 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
7829   bool jresult ;
7830   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7831   Dali::Rect< int > *arg2 = 0 ;
7832   bool result;
7833
7834   arg1 = (Dali::Property::Value *)jarg1;
7835   arg2 = (Dali::Rect< int > *)jarg2;
7836   if (!arg2) {
7837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
7838     return 0;
7839   }
7840   {
7841     try {
7842       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7843     } CALL_CATCH_EXCEPTION(0);
7844   }
7845
7846   jresult = result;
7847   return jresult;
7848 }
7849
7850
7851 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
7852   bool jresult ;
7853   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7854   Dali::Vector2 *arg2 = 0 ;
7855   bool result;
7856
7857   arg1 = (Dali::Property::Value *)jarg1;
7858   arg2 = (Dali::Vector2 *)jarg2;
7859   if (!arg2) {
7860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
7861     return 0;
7862   }
7863   {
7864     try {
7865       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7866     } CALL_CATCH_EXCEPTION(0);
7867   }
7868
7869   jresult = result;
7870   return jresult;
7871 }
7872
7873
7874 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
7875   bool jresult ;
7876   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7877   Dali::Vector3 *arg2 = 0 ;
7878   bool result;
7879
7880   arg1 = (Dali::Property::Value *)jarg1;
7881   arg2 = (Dali::Vector3 *)jarg2;
7882   if (!arg2) {
7883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7884     return 0;
7885   }
7886   {
7887     try {
7888       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7889     } CALL_CATCH_EXCEPTION(0);
7890   }
7891
7892   jresult = result;
7893   return jresult;
7894 }
7895
7896
7897 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
7898   bool jresult ;
7899   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7900   Dali::Vector4 *arg2 = 0 ;
7901   bool result;
7902
7903   arg1 = (Dali::Property::Value *)jarg1;
7904   arg2 = (Dali::Vector4 *)jarg2;
7905   if (!arg2) {
7906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
7907     return 0;
7908   }
7909   {
7910     try {
7911       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7912     } CALL_CATCH_EXCEPTION(0);
7913   }
7914
7915   jresult = result;
7916   return jresult;
7917 }
7918
7919
7920 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
7921   bool jresult ;
7922   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7923   Dali::Matrix3 *arg2 = 0 ;
7924   bool result;
7925
7926   arg1 = (Dali::Property::Value *)jarg1;
7927   arg2 = (Dali::Matrix3 *)jarg2;
7928   if (!arg2) {
7929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
7930     return 0;
7931   }
7932   {
7933     try {
7934       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7935     } CALL_CATCH_EXCEPTION(0);
7936   }
7937
7938   jresult = result;
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
7944   bool jresult ;
7945   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7946   Dali::Matrix *arg2 = 0 ;
7947   bool result;
7948
7949   arg1 = (Dali::Property::Value *)jarg1;
7950   arg2 = (Dali::Matrix *)jarg2;
7951   if (!arg2) {
7952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7953     return 0;
7954   }
7955   {
7956     try {
7957       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7958     } CALL_CATCH_EXCEPTION(0);
7959   }
7960
7961   jresult = result;
7962   return jresult;
7963 }
7964
7965
7966 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
7967   bool jresult ;
7968   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7969   Dali::AngleAxis *arg2 = 0 ;
7970   bool result;
7971
7972   arg1 = (Dali::Property::Value *)jarg1;
7973   arg2 = (Dali::AngleAxis *)jarg2;
7974   if (!arg2) {
7975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
7976     return 0;
7977   }
7978   {
7979     try {
7980       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7981     } CALL_CATCH_EXCEPTION(0);
7982   }
7983
7984   jresult = result;
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
7990   bool jresult ;
7991   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7992   Dali::Quaternion *arg2 = 0 ;
7993   bool result;
7994
7995   arg1 = (Dali::Property::Value *)jarg1;
7996   arg2 = (Dali::Quaternion *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8004     } CALL_CATCH_EXCEPTION(0);
8005   }
8006
8007   jresult = result;
8008   return jresult;
8009 }
8010
8011
8012 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
8013   bool jresult ;
8014   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8015   std::string *arg2 = 0 ;
8016   bool result;
8017
8018   arg1 = (Dali::Property::Value *)jarg1;
8019
8020   //typemap in
8021   std::string temp;
8022   arg2 = &temp;
8023
8024   {
8025     try {
8026       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8027     } CALL_CATCH_EXCEPTION(0);
8028   }
8029
8030   jresult = result;
8031
8032   //Typemap argout in c++ file.
8033   //This will convert c++ string to c# string
8034   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
8035
8036   return jresult;
8037 }
8038
8039
8040 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
8041   bool jresult ;
8042   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8043   Dali::Property::Array *arg2 = 0 ;
8044   bool result;
8045
8046   arg1 = (Dali::Property::Value *)jarg1;
8047   arg2 = (Dali::Property::Array *)jarg2;
8048   if (!arg2) {
8049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
8050     return 0;
8051   }
8052   {
8053     try {
8054       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8055     } CALL_CATCH_EXCEPTION(0);
8056   }
8057
8058   jresult = result;
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
8064   bool jresult ;
8065   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8066   Dali::Property::Map *arg2 = 0 ;
8067   bool result;
8068
8069   arg1 = (Dali::Property::Value *)jarg1;
8070   arg2 = (Dali::Property::Map *)jarg2;
8071   if (!arg2) {
8072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
8073     return 0;
8074   }
8075   {
8076     try {
8077       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8078     } CALL_CATCH_EXCEPTION(0);
8079   }
8080
8081   jresult = result;
8082   return jresult;
8083 }
8084
8085
8086 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
8087   bool jresult ;
8088   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8089   Extents *arg2 = 0 ;
8090   bool result;
8091
8092   arg1 = (Dali::Property::Value *)jarg1;
8093   arg2 = (Extents *)jarg2;
8094   if (!arg2) {
8095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
8096     return 0;
8097   }
8098   {
8099     try {
8100       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
8101     } CALL_CATCH_EXCEPTION(0);
8102   }
8103   jresult = result;
8104   return jresult;
8105 }
8106
8107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
8108   void * jresult ;
8109   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8110   Dali::Property::Array *result = 0 ;
8111
8112   arg1 = (Dali::Property::Value *)jarg1;
8113   {
8114     try {
8115       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
8116     } CALL_CATCH_EXCEPTION(0);
8117   }
8118
8119   jresult = (void *)result;
8120   return jresult;
8121 }
8122
8123
8124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
8125   void * jresult ;
8126   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
8127   Dali::Property::Map *result = 0 ;
8128
8129   arg1 = (Dali::Property::Value *)jarg1;
8130   {
8131     try {
8132       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
8133     } CALL_CATCH_EXCEPTION(0);
8134   }
8135
8136   jresult = (void *)result;
8137   return jresult;
8138 }
8139
8140
8141 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
8142   char * jresult ;
8143   Dali::Property::Type arg1 ;
8144   char *result = 0 ;
8145
8146   arg1 = (Dali::Property::Type)jarg1;
8147   {
8148     try {
8149       result = (char *)Dali::PropertyTypes::GetName(arg1);
8150     } CALL_CATCH_EXCEPTION(0);
8151   }
8152
8153   jresult = SWIG_csharp_string_callback((const char *)result);
8154   return jresult;
8155 }
8156
8157
8158 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
8159   bool jresult ;
8160   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8161   std::string *arg2 = 0 ;
8162   Dali::Property::Map *arg3 = 0 ;
8163   bool result;
8164
8165   arg1 = (Dali::BaseObject *)jarg1;
8166   if (!jarg2) {
8167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8168     return 0;
8169   }
8170   std::string arg2_str(jarg2);
8171   arg2 = &arg2_str;
8172   arg3 = (Dali::Property::Map *)jarg3;
8173   if (!arg3) {
8174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
8175     return 0;
8176   }
8177   {
8178     try {
8179       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
8180     } CALL_CATCH_EXCEPTION(0);
8181   }
8182
8183   jresult = result;
8184
8185   //argout typemap for const std::string&
8186
8187   return jresult;
8188 }
8189
8190
8191 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
8192   char * jresult ;
8193   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8194   std::string *result = 0 ;
8195
8196   arg1 = (Dali::BaseObject *)jarg1;
8197   {
8198     try {
8199       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
8200     } CALL_CATCH_EXCEPTION(0);
8201   }
8202
8203   jresult = SWIG_csharp_string_callback(result->c_str());
8204   return jresult;
8205 }
8206
8207
8208 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
8209   bool jresult ;
8210   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8211   Dali::TypeInfo *arg2 = 0 ;
8212   bool result;
8213
8214   arg1 = (Dali::BaseObject *)jarg1;
8215   arg2 = (Dali::TypeInfo *)jarg2;
8216   if (!arg2) {
8217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
8218     return 0;
8219   }
8220   {
8221     try {
8222       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
8223     } CALL_CATCH_EXCEPTION(0);
8224   }
8225
8226   jresult = result;
8227   return jresult;
8228 }
8229
8230
8231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
8232   bool jresult ;
8233   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8234   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
8235   std::string *arg3 = 0 ;
8236   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
8237   bool result;
8238
8239   arg1 = (Dali::BaseObject *)jarg1;
8240   arg2 = (ConnectionTrackerInterface *)jarg2;
8241   if (!jarg3) {
8242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8243     return 0;
8244   }
8245   std::string arg3_str(jarg3);
8246   arg3 = &arg3_str;
8247   arg4 = (FunctorDelegate *)jarg4;
8248   {
8249     try {
8250       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
8251     } CALL_CATCH_EXCEPTION(0);
8252   }
8253
8254   jresult = result;
8255
8256   //argout typemap for const std::string&
8257
8258   return jresult;
8259 }
8260
8261
8262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
8263   void * jresult ;
8264   Dali::BaseHandle *arg1 = 0 ;
8265   Dali::BaseObject *result = 0 ;
8266
8267   arg1 = (Dali::BaseHandle *)jarg1;
8268   if (!arg1) {
8269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8270     return 0;
8271   }
8272   {
8273     try {
8274       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
8275     } CALL_CATCH_EXCEPTION(0);
8276   }
8277
8278   jresult = (void *)result;
8279   return jresult;
8280 }
8281
8282
8283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
8284   void * jresult ;
8285   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
8286   Dali::BaseHandle *result = 0 ;
8287
8288   arg1 = (Dali::BaseObject *)jarg1;
8289   {
8290     try {
8291       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
8292     } CALL_CATCH_EXCEPTION(0);
8293   }
8294
8295   jresult = (void *)result;
8296   return jresult;
8297 }
8298
8299
8300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
8301   void * jresult ;
8302   Dali::BaseHandle *result = 0 ;
8303
8304   {
8305     try {
8306       result = (Dali::BaseHandle *)new Dali::BaseHandle();
8307     } CALL_CATCH_EXCEPTION(0);
8308   }
8309
8310   jresult = (void *)result;
8311   return jresult;
8312 }
8313
8314
8315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
8316   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8317
8318   arg1 = (Dali::BaseHandle *)jarg1;
8319   {
8320     try {
8321       delete arg1;
8322     } CALL_CATCH_EXCEPTION();
8323   }
8324
8325 }
8326
8327
8328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
8329   void * jresult ;
8330   Dali::BaseHandle *arg1 = 0 ;
8331   Dali::BaseHandle *result = 0 ;
8332
8333   arg1 = (Dali::BaseHandle *)jarg1;
8334   if (!arg1) {
8335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8336     return 0;
8337   }
8338   {
8339     try {
8340       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
8341     } CALL_CATCH_EXCEPTION(0);
8342   }
8343
8344   jresult = (void *)result;
8345   return jresult;
8346 }
8347
8348
8349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
8350   void * jresult ;
8351   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8352   Dali::BaseHandle *arg2 = 0 ;
8353   Dali::BaseHandle *result = 0 ;
8354
8355   arg1 = (Dali::BaseHandle *)jarg1;
8356   arg2 = (Dali::BaseHandle *)jarg2;
8357   if (!arg2) {
8358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8359     return 0;
8360   }
8361   {
8362     try {
8363       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
8364     } CALL_CATCH_EXCEPTION(0);
8365   }
8366
8367   jresult = (void *)result;
8368   return jresult;
8369 }
8370
8371
8372 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
8373   bool jresult ;
8374   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8375   std::string *arg2 = 0 ;
8376   Dali::Property::Map *arg3 = 0 ;
8377   bool result;
8378
8379   arg1 = (Dali::BaseHandle *)jarg1;
8380   if (!jarg2) {
8381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
8382     return 0;
8383   }
8384   std::string arg2_str(jarg2);
8385   arg2 = &arg2_str;
8386   arg3 = (Dali::Property::Map *)jarg3;
8387   if (!arg3) {
8388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
8389     return 0;
8390   }
8391   {
8392     try {
8393       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
8394     } CALL_CATCH_EXCEPTION(0);
8395   }
8396
8397   jresult = result;
8398
8399   //argout typemap for const std::string&
8400
8401   return jresult;
8402 }
8403
8404
8405 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
8406   char * jresult ;
8407   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8408   std::string *result = 0 ;
8409
8410   arg1 = (Dali::BaseHandle *)jarg1;
8411   {
8412     try {
8413       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
8414     } CALL_CATCH_EXCEPTION(0);
8415   }
8416
8417   jresult = SWIG_csharp_string_callback(result->c_str());
8418   return jresult;
8419 }
8420
8421
8422 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
8423   bool jresult ;
8424   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8425   Dali::TypeInfo *arg2 = 0 ;
8426   bool result;
8427
8428   arg1 = (Dali::BaseHandle *)jarg1;
8429   arg2 = (Dali::TypeInfo *)jarg2;
8430   if (!arg2) {
8431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
8432     return 0;
8433   }
8434   {
8435     try {
8436       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
8437     } CALL_CATCH_EXCEPTION(0);
8438   }
8439
8440   jresult = result;
8441   return jresult;
8442 }
8443
8444
8445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
8446   void * jresult ;
8447   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8448   Dali::BaseObject *result = 0 ;
8449
8450   arg1 = (Dali::BaseHandle *)jarg1;
8451   {
8452     try {
8453       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
8454     } CALL_CATCH_EXCEPTION(0);
8455   }
8456
8457   jresult = (void *)result;
8458   return jresult;
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
8463   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8464
8465   arg1 = (Dali::BaseHandle *)jarg1;
8466   {
8467     try {
8468       (arg1)->Reset();
8469     } CALL_CATCH_EXCEPTION();
8470   }
8471
8472 }
8473
8474
8475 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
8476   bool jresult ;
8477   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8478   Dali::BaseHandle *arg2 = 0 ;
8479   bool result;
8480
8481   arg1 = (Dali::BaseHandle *)jarg1;
8482   arg2 = (Dali::BaseHandle *)jarg2;
8483   if (!arg2) {
8484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8485     return 0;
8486   }
8487   {
8488     try {
8489       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
8490     } CALL_CATCH_EXCEPTION(0);
8491   }
8492
8493   jresult = result;
8494   return jresult;
8495 }
8496
8497
8498 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
8499   bool jresult ;
8500   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8501   Dali::BaseHandle *arg2 = 0 ;
8502   bool result;
8503
8504   arg1 = (Dali::BaseHandle *)jarg1;
8505   arg2 = (Dali::BaseHandle *)jarg2;
8506   if (!arg2) {
8507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8508     return 0;
8509   }
8510   {
8511     try {
8512       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
8513     } CALL_CATCH_EXCEPTION(0);
8514   }
8515
8516   jresult = result;
8517   return jresult;
8518 }
8519
8520
8521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
8522   void * jresult ;
8523   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8524   Dali::RefObject *result = 0 ;
8525
8526   arg1 = (Dali::BaseHandle *)jarg1;
8527   {
8528     try {
8529       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
8530     } CALL_CATCH_EXCEPTION(0);
8531   }
8532
8533   jresult = (void *)result;
8534   return jresult;
8535 }
8536
8537
8538 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
8539   bool jresult ;
8540   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8541   bool result;
8542
8543   arg1 = (Dali::BaseHandle *)jarg1;
8544   {
8545     try {
8546       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
8547     } CALL_CATCH_EXCEPTION(0);
8548   }
8549
8550   jresult = result;
8551   return jresult;
8552 }
8553
8554
8555 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
8556   bool jresult ;
8557   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8558   Dali::BaseHandle *arg2 = 0 ;
8559   bool result;
8560
8561   arg1 = (Dali::BaseHandle *)jarg1;
8562   arg2 = (Dali::BaseHandle *)jarg2;
8563   if (!arg2) {
8564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8565     return 0;
8566   }
8567   {
8568     try {
8569       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
8570     } CALL_CATCH_EXCEPTION(0);
8571   }
8572
8573   jresult = result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
8579   bool jresult ;
8580   Dali::BaseHandle *arg1 = 0 ;
8581   Dali::BaseHandle *arg2 = 0 ;
8582   bool result;
8583
8584   arg1 = (Dali::BaseHandle *)jarg1;
8585   if (!arg1) {
8586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8587     return 0;
8588   }
8589   arg2 = (Dali::BaseHandle *)jarg2;
8590   if (!arg2) {
8591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8592     return 0;
8593   }
8594   {
8595     try {
8596       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
8597     } CALL_CATCH_EXCEPTION(0);
8598   }
8599
8600   jresult = result;
8601   return jresult;
8602 }
8603
8604
8605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
8606   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
8607
8608   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
8609   {
8610     try {
8611       delete arg1;
8612     } CALL_CATCH_EXCEPTION();
8613   }
8614
8615 }
8616
8617
8618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
8619   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
8620   SlotObserver *arg2 = (SlotObserver *) 0 ;
8621   CallbackBase *arg3 = (CallbackBase *) 0 ;
8622
8623   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
8624   arg2 = (SlotObserver *)jarg2;
8625   arg3 = (CallbackBase *)jarg3;
8626   {
8627     try {
8628       (arg1)->SignalConnected(arg2,arg3);
8629     } CALL_CATCH_EXCEPTION();
8630   }
8631
8632 }
8633
8634
8635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
8636   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
8637
8638   arg1 = (Dali::SignalObserver *)jarg1;
8639   {
8640     try {
8641       delete arg1;
8642     } CALL_CATCH_EXCEPTION();
8643   }
8644
8645 }
8646
8647
8648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
8649   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
8650   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8651   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8652
8653   arg1 = (Dali::SignalObserver *)jarg1;
8654   arg2 = (Dali::SlotObserver *)jarg2;
8655   arg3 = (Dali::CallbackBase *)jarg3;
8656   {
8657     try {
8658       (arg1)->SignalDisconnected(arg2,arg3);
8659     } CALL_CATCH_EXCEPTION();
8660   }
8661
8662 }
8663
8664
8665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
8666   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
8667
8668   arg1 = (Dali::SlotObserver *)jarg1;
8669   {
8670     try {
8671       delete arg1;
8672     } CALL_CATCH_EXCEPTION();
8673   }
8674
8675 }
8676
8677
8678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
8679   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
8680   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
8681
8682   arg1 = (Dali::SlotObserver *)jarg1;
8683   arg2 = (Dali::CallbackBase *)jarg2;
8684   {
8685     try {
8686       (arg1)->SlotDisconnected(arg2);
8687     } CALL_CATCH_EXCEPTION();
8688   }
8689
8690 }
8691
8692
8693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
8694   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8695
8696   arg1 = (Dali::ConnectionTracker *)jarg1;
8697   {
8698     try {
8699       delete arg1;
8700     } CALL_CATCH_EXCEPTION();
8701   }
8702
8703 }
8704
8705
8706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
8707   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8708
8709   arg1 = (Dali::ConnectionTracker *)jarg1;
8710   {
8711     try {
8712       (arg1)->DisconnectAll();
8713     } CALL_CATCH_EXCEPTION();
8714   }
8715
8716 }
8717
8718
8719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
8720   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8721   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8722   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8723
8724   arg1 = (Dali::ConnectionTracker *)jarg1;
8725   arg2 = (Dali::SlotObserver *)jarg2;
8726   arg3 = (Dali::CallbackBase *)jarg3;
8727   {
8728     try {
8729       (arg1)->SignalConnected(arg2,arg3);
8730     } CALL_CATCH_EXCEPTION();
8731   }
8732
8733 }
8734
8735
8736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
8737   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8738   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8739   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8740
8741   arg1 = (Dali::ConnectionTracker *)jarg1;
8742   arg2 = (Dali::SlotObserver *)jarg2;
8743   arg3 = (Dali::CallbackBase *)jarg3;
8744   {
8745     try {
8746       (arg1)->SignalDisconnected(arg2,arg3);
8747     } CALL_CATCH_EXCEPTION();
8748   }
8749
8750 }
8751
8752
8753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
8754   unsigned long jresult ;
8755   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8756   std::size_t result;
8757
8758   arg1 = (Dali::ConnectionTracker *)jarg1;
8759   {
8760     try {
8761       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
8762     } CALL_CATCH_EXCEPTION(0);
8763   }
8764
8765   jresult = (unsigned long)result;
8766   return jresult;
8767 }
8768
8769
8770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
8771   void * jresult ;
8772   Dali::ObjectRegistry *result = 0 ;
8773
8774   {
8775     try {
8776       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
8777     } CALL_CATCH_EXCEPTION(0);
8778   }
8779
8780   jresult = (void *)result;
8781   return jresult;
8782 }
8783
8784
8785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
8786   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8787
8788   arg1 = (Dali::ObjectRegistry *)jarg1;
8789   {
8790     try {
8791       delete arg1;
8792     } CALL_CATCH_EXCEPTION();
8793   }
8794
8795 }
8796
8797
8798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
8799   void * jresult ;
8800   Dali::ObjectRegistry *arg1 = 0 ;
8801   Dali::ObjectRegistry *result = 0 ;
8802
8803   arg1 = (Dali::ObjectRegistry *)jarg1;
8804   if (!arg1) {
8805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
8806     return 0;
8807   }
8808   {
8809     try {
8810       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
8811     } CALL_CATCH_EXCEPTION(0);
8812   }
8813
8814   jresult = (void *)result;
8815   return jresult;
8816 }
8817
8818
8819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
8820   void * jresult ;
8821   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8822   Dali::ObjectRegistry *arg2 = 0 ;
8823   Dali::ObjectRegistry *result = 0 ;
8824
8825   arg1 = (Dali::ObjectRegistry *)jarg1;
8826   arg2 = (Dali::ObjectRegistry *)jarg2;
8827   if (!arg2) {
8828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
8829     return 0;
8830   }
8831   {
8832     try {
8833       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
8834     } CALL_CATCH_EXCEPTION(0);
8835   }
8836
8837   jresult = (void *)result;
8838   return jresult;
8839 }
8840
8841
8842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
8843   void * jresult ;
8844   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8845   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
8846
8847   arg1 = (Dali::ObjectRegistry *)jarg1;
8848   {
8849     try {
8850       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
8851     } CALL_CATCH_EXCEPTION(0);
8852   }
8853
8854   jresult = (void *)result;
8855   return jresult;
8856 }
8857
8858
8859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
8860   void * jresult ;
8861   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8862   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
8863
8864   arg1 = (Dali::ObjectRegistry *)jarg1;
8865   {
8866     try {
8867       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
8868     } CALL_CATCH_EXCEPTION(0);
8869   }
8870
8871   jresult = (void *)result;
8872   return jresult;
8873 }
8874
8875
8876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
8877   void * jresult ;
8878   Dali::PropertyCondition *result = 0 ;
8879
8880   {
8881     try {
8882       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
8883     } CALL_CATCH_EXCEPTION(0);
8884   }
8885
8886   jresult = (void *)result;
8887   return jresult;
8888 }
8889
8890
8891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
8892   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8893
8894   arg1 = (Dali::PropertyCondition *)jarg1;
8895   {
8896     try {
8897       delete arg1;
8898     } CALL_CATCH_EXCEPTION();
8899   }
8900
8901 }
8902
8903
8904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
8905   void * jresult ;
8906   Dali::PropertyCondition *arg1 = 0 ;
8907   Dali::PropertyCondition *result = 0 ;
8908
8909   arg1 = (Dali::PropertyCondition *)jarg1;
8910   if (!arg1) {
8911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
8912     return 0;
8913   }
8914   {
8915     try {
8916       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
8917     } CALL_CATCH_EXCEPTION(0);
8918   }
8919
8920   jresult = (void *)result;
8921   return jresult;
8922 }
8923
8924
8925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
8926   void * jresult ;
8927   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8928   Dali::PropertyCondition *arg2 = 0 ;
8929   Dali::PropertyCondition *result = 0 ;
8930
8931   arg1 = (Dali::PropertyCondition *)jarg1;
8932   arg2 = (Dali::PropertyCondition *)jarg2;
8933   if (!arg2) {
8934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
8935     return 0;
8936   }
8937   {
8938     try {
8939       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
8940     } CALL_CATCH_EXCEPTION(0);
8941   }
8942
8943   jresult = (void *)result;
8944   return jresult;
8945 }
8946
8947
8948 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
8949   unsigned long jresult ;
8950   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8951   std::size_t result;
8952
8953   arg1 = (Dali::PropertyCondition *)jarg1;
8954   {
8955     try {
8956       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
8957     } CALL_CATCH_EXCEPTION(0);
8958   }
8959   jresult = (unsigned long)result;
8960   return jresult;
8961 }
8962
8963
8964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
8965   float jresult ;
8966   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8967   std::size_t arg2 ;
8968   float result;
8969
8970   arg1 = (Dali::PropertyCondition *)jarg1;
8971   arg2 = (std::size_t)jarg2;
8972   {
8973     try {
8974       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
8975     } CALL_CATCH_EXCEPTION(0);
8976   }
8977   jresult = result;
8978   return jresult;
8979 }
8980
8981
8982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
8983   void * jresult ;
8984   float arg1 ;
8985   Dali::PropertyCondition result;
8986
8987   arg1 = (float)jarg1;
8988   {
8989     try {
8990       result = Dali::LessThanCondition(arg1);
8991     } CALL_CATCH_EXCEPTION(0);
8992   }
8993
8994   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8995   return jresult;
8996 }
8997
8998
8999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
9000   void * jresult ;
9001   float arg1 ;
9002   Dali::PropertyCondition result;
9003
9004   arg1 = (float)jarg1;
9005   {
9006     try {
9007       result = Dali::GreaterThanCondition(arg1);
9008     } CALL_CATCH_EXCEPTION(0);
9009   }
9010
9011   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9012   return jresult;
9013 }
9014
9015
9016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
9017   void * jresult ;
9018   float arg1 ;
9019   float arg2 ;
9020   Dali::PropertyCondition result;
9021
9022   arg1 = (float)jarg1;
9023   arg2 = (float)jarg2;
9024   {
9025     try {
9026       result = Dali::InsideCondition(arg1,arg2);
9027     } CALL_CATCH_EXCEPTION(0);
9028   }
9029
9030   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9031   return jresult;
9032 }
9033
9034
9035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
9036   void * jresult ;
9037   float arg1 ;
9038   float arg2 ;
9039   Dali::PropertyCondition result;
9040
9041   arg1 = (float)jarg1;
9042   arg2 = (float)jarg2;
9043   {
9044     try {
9045       result = Dali::OutsideCondition(arg1,arg2);
9046     } CALL_CATCH_EXCEPTION(0);
9047   }
9048
9049   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9050   return jresult;
9051 }
9052
9053
9054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
9055   void * jresult ;
9056   float arg1 ;
9057   float arg2 ;
9058   Dali::PropertyCondition result;
9059
9060   arg1 = (float)jarg1;
9061   arg2 = (float)jarg2;
9062   {
9063     try {
9064       result = Dali::StepCondition(arg1,arg2);
9065     } CALL_CATCH_EXCEPTION(0);
9066   }
9067
9068   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9069   return jresult;
9070 }
9071
9072
9073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
9074   void * jresult ;
9075   float arg1 ;
9076   Dali::PropertyCondition result;
9077
9078   arg1 = (float)jarg1;
9079   {
9080     try {
9081       result = Dali::StepCondition(arg1);
9082     } CALL_CATCH_EXCEPTION(0);
9083   }
9084
9085   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9086   return jresult;
9087 }
9088
9089
9090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
9091   void * jresult ;
9092   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
9093   Dali::PropertyCondition result;
9094
9095   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
9096   if (!arg1) {
9097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
9098     return 0;
9099   }
9100   {
9101     try {
9102       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
9103     } CALL_CATCH_EXCEPTION(0);
9104   }
9105
9106   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9107   return jresult;
9108 }
9109
9110
9111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
9112   void * jresult ;
9113   Dali::PropertyNotification *result = 0 ;
9114
9115   {
9116     try {
9117       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
9118     } CALL_CATCH_EXCEPTION(0);
9119   }
9120
9121   jresult = (void *)result;
9122   return jresult;
9123 }
9124
9125
9126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
9127   void * jresult ;
9128   Dali::BaseHandle arg1 ;
9129   Dali::BaseHandle *argp1 ;
9130   Dali::PropertyNotification result;
9131
9132   argp1 = (Dali::BaseHandle *)jarg1;
9133   if (!argp1) {
9134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
9135     return 0;
9136   }
9137   arg1 = *argp1;
9138   {
9139     try {
9140       result = Dali::PropertyNotification::DownCast(arg1);
9141     } CALL_CATCH_EXCEPTION(0);
9142   }
9143
9144   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9145   return jresult;
9146 }
9147
9148
9149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
9150   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9151
9152   arg1 = (Dali::PropertyNotification *)jarg1;
9153   {
9154     try {
9155       delete arg1;
9156     } CALL_CATCH_EXCEPTION();
9157   }
9158
9159 }
9160
9161
9162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
9163   void * jresult ;
9164   Dali::PropertyNotification *arg1 = 0 ;
9165   Dali::PropertyNotification *result = 0 ;
9166
9167   arg1 = (Dali::PropertyNotification *)jarg1;
9168   if (!arg1) {
9169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
9170     return 0;
9171   }
9172   {
9173     try {
9174       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
9175     } CALL_CATCH_EXCEPTION(0);
9176   }
9177
9178   jresult = (void *)result;
9179   return jresult;
9180 }
9181
9182
9183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
9184   void * jresult ;
9185   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9186   Dali::PropertyNotification *arg2 = 0 ;
9187   Dali::PropertyNotification *result = 0 ;
9188
9189   arg1 = (Dali::PropertyNotification *)jarg1;
9190   arg2 = (Dali::PropertyNotification *)jarg2;
9191   if (!arg2) {
9192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
9193     return 0;
9194   }
9195   {
9196     try {
9197       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
9198     } CALL_CATCH_EXCEPTION(0);
9199   }
9200
9201   jresult = (void *)result;
9202   return jresult;
9203 }
9204
9205
9206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
9207   void * jresult ;
9208   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9209   Dali::PropertyCondition result;
9210
9211   arg1 = (Dali::PropertyNotification *)jarg1;
9212   {
9213     try {
9214       result = (arg1)->GetCondition();
9215     } CALL_CATCH_EXCEPTION(0);
9216   }
9217
9218   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
9219   return jresult;
9220 }
9221
9222
9223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
9224   void * jresult ;
9225   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9226   Dali::Handle result;
9227
9228   arg1 = (Dali::PropertyNotification *)jarg1;
9229   {
9230     try {
9231       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
9232     } CALL_CATCH_EXCEPTION(0);
9233   }
9234
9235   jresult = new Dali::Handle((const Dali::Handle &)result);
9236   return jresult;
9237 }
9238
9239
9240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
9241   int jresult ;
9242   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9243   Dali::Property::Index result;
9244
9245   arg1 = (Dali::PropertyNotification *)jarg1;
9246   {
9247     try {
9248       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
9249     } CALL_CATCH_EXCEPTION(0);
9250   }
9251
9252   jresult = result;
9253   return jresult;
9254 }
9255
9256
9257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
9258   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9259   Dali::PropertyNotification::NotifyMode arg2 ;
9260
9261   arg1 = (Dali::PropertyNotification *)jarg1;
9262   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
9263   {
9264     try {
9265       (arg1)->SetNotifyMode(arg2);
9266     } CALL_CATCH_EXCEPTION();
9267   }
9268
9269 }
9270
9271
9272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
9273   int jresult ;
9274   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9275   Dali::PropertyNotification::NotifyMode result;
9276
9277   arg1 = (Dali::PropertyNotification *)jarg1;
9278   {
9279     try {
9280       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
9281     } CALL_CATCH_EXCEPTION(0);
9282   }
9283
9284   jresult = (int)result;
9285   return jresult;
9286 }
9287
9288
9289 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
9290   bool jresult ;
9291   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9292   bool result;
9293
9294   arg1 = (Dali::PropertyNotification *)jarg1;
9295   {
9296     try {
9297       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
9298     } CALL_CATCH_EXCEPTION(0);
9299   }
9300
9301   jresult = result;
9302   return jresult;
9303 }
9304
9305
9306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
9307   void * jresult ;
9308   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
9309   Dali::PropertyNotifySignalType *result = 0 ;
9310
9311   arg1 = (Dali::PropertyNotification *)jarg1;
9312   {
9313     try {
9314       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
9315     } CALL_CATCH_EXCEPTION(0);
9316   }
9317
9318   jresult = (void *)result;
9319   return jresult;
9320 }
9321
9322
9323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
9324   void * jresult ;
9325   Dali::Handle *result = 0 ;
9326
9327   {
9328     try {
9329       result = (Dali::Handle *)new Dali::Handle();
9330     } CALL_CATCH_EXCEPTION(0);
9331   }
9332
9333   jresult = (void *)result;
9334   return jresult;
9335 }
9336
9337
9338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
9339   void * jresult ;
9340   Dali::Handle result;
9341
9342   {
9343     try {
9344       result = Dali::Handle::New();
9345     } CALL_CATCH_EXCEPTION(0);
9346   }
9347
9348   jresult = new Dali::Handle((const Dali::Handle &)result);
9349   return jresult;
9350 }
9351
9352
9353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
9354   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9355
9356   arg1 = (Dali::Handle *)jarg1;
9357   {
9358     try {
9359       delete arg1;
9360     } CALL_CATCH_EXCEPTION();
9361   }
9362
9363 }
9364
9365
9366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
9367   void * jresult ;
9368   Dali::Handle *arg1 = 0 ;
9369   Dali::Handle *result = 0 ;
9370
9371   arg1 = (Dali::Handle *)jarg1;
9372   if (!arg1) {
9373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
9374     return 0;
9375   }
9376   {
9377     try {
9378       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
9379     } CALL_CATCH_EXCEPTION(0);
9380   }
9381
9382   jresult = (void *)result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
9388   void * jresult ;
9389   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9390   Dali::Handle *arg2 = 0 ;
9391   Dali::Handle *result = 0 ;
9392
9393   arg1 = (Dali::Handle *)jarg1;
9394   arg2 = (Dali::Handle *)jarg2;
9395   if (!arg2) {
9396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
9397     return 0;
9398   }
9399   {
9400     try {
9401       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
9402     } CALL_CATCH_EXCEPTION(0);
9403   }
9404
9405   jresult = (void *)result;
9406   return jresult;
9407 }
9408
9409
9410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
9411   void * jresult ;
9412   Dali::BaseHandle arg1 ;
9413   Dali::BaseHandle *argp1 ;
9414   Dali::Handle result;
9415
9416   argp1 = (Dali::BaseHandle *)jarg1;
9417   if (!argp1) {
9418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
9419     return 0;
9420   }
9421   arg1 = *argp1;
9422   {
9423     try {
9424       result = Dali::Handle::DownCast(arg1);
9425     } CALL_CATCH_EXCEPTION(0);
9426   }
9427
9428   jresult = new Dali::Handle((const Dali::Handle &)result);
9429   return jresult;
9430 }
9431
9432
9433 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
9434   bool jresult ;
9435   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9436   Dali::Handle::Capability arg2 ;
9437   bool result;
9438
9439   arg1 = (Dali::Handle *)jarg1;
9440   arg2 = (Dali::Handle::Capability)jarg2;
9441   {
9442     try {
9443       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
9444     } CALL_CATCH_EXCEPTION(0);
9445   }
9446
9447   jresult = result;
9448   return jresult;
9449 }
9450
9451
9452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
9453   unsigned int jresult ;
9454   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9455   unsigned int result;
9456
9457   arg1 = (Dali::Handle *)jarg1;
9458   {
9459     try {
9460       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
9461     } CALL_CATCH_EXCEPTION(0);
9462   }
9463
9464   jresult = result;
9465   return jresult;
9466 }
9467
9468
9469 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
9470   char * jresult ;
9471   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9472   Dali::Property::Index arg2 ;
9473   std::string result;
9474
9475   arg1 = (Dali::Handle *)jarg1;
9476   arg2 = (Dali::Property::Index)jarg2;
9477   {
9478     try {
9479       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
9480     } CALL_CATCH_EXCEPTION(0);
9481   }
9482
9483   jresult = SWIG_csharp_string_callback((&result)->c_str());
9484   return jresult;
9485 }
9486
9487
9488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
9489   int jresult ;
9490   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9491   std::string *arg2 = 0 ;
9492   Dali::Property::Index result;
9493
9494   arg1 = (Dali::Handle *)jarg1;
9495   if (!jarg2) {
9496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9497     return 0;
9498   }
9499   std::string arg2_str(jarg2);
9500   arg2 = &arg2_str;
9501   {
9502     try {
9503       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
9504     } CALL_CATCH_EXCEPTION(0);
9505   }
9506
9507   jresult = result;
9508
9509   //argout typemap for const std::string&
9510
9511   return jresult;
9512 }
9513
9514
9515 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
9516   bool jresult ;
9517   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9518   Dali::Property::Index arg2 ;
9519   bool result;
9520
9521   arg1 = (Dali::Handle *)jarg1;
9522   arg2 = (Dali::Property::Index)jarg2;
9523   {
9524     try {
9525       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
9526     } CALL_CATCH_EXCEPTION(0);
9527   }
9528
9529   jresult = result;
9530   return jresult;
9531 }
9532
9533
9534 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
9535   bool jresult ;
9536   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9537   Dali::Property::Index arg2 ;
9538   bool result;
9539
9540   arg1 = (Dali::Handle *)jarg1;
9541   arg2 = (Dali::Property::Index)jarg2;
9542   {
9543     try {
9544       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
9545     } CALL_CATCH_EXCEPTION(0);
9546   }
9547
9548   jresult = result;
9549   return jresult;
9550 }
9551
9552
9553 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
9554   bool jresult ;
9555   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9556   Dali::Property::Index arg2 ;
9557   bool result;
9558
9559   arg1 = (Dali::Handle *)jarg1;
9560   arg2 = (Dali::Property::Index)jarg2;
9561   {
9562     try {
9563       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
9564     } CALL_CATCH_EXCEPTION(0);
9565   }
9566
9567   jresult = result;
9568   return jresult;
9569 }
9570
9571
9572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
9573   int jresult ;
9574   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9575   Dali::Property::Index arg2 ;
9576   Dali::Property::Type result;
9577
9578   arg1 = (Dali::Handle *)jarg1;
9579   arg2 = (Dali::Property::Index)jarg2;
9580   {
9581     try {
9582       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
9583     } CALL_CATCH_EXCEPTION(0);
9584   }
9585
9586   jresult = (int)result;
9587   return jresult;
9588 }
9589
9590
9591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
9592   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9593   Dali::Property::Index arg2 ;
9594   Dali::Property::Value *arg3 = 0 ;
9595
9596   arg1 = (Dali::Handle *)jarg1;
9597   arg2 = (Dali::Property::Index)jarg2;
9598   arg3 = (Dali::Property::Value *)jarg3;
9599   if (!arg3) {
9600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9601     return ;
9602   }
9603   {
9604     try {
9605       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
9606     } CALL_CATCH_EXCEPTION();
9607   }
9608
9609 }
9610
9611
9612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9613   int jresult ;
9614   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9615   std::string *arg2 = 0 ;
9616   Dali::Property::Value *arg3 = 0 ;
9617   Dali::Property::Index result;
9618
9619   arg1 = (Dali::Handle *)jarg1;
9620   if (!jarg2) {
9621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9622     return 0;
9623   }
9624   std::string arg2_str(jarg2);
9625   arg2 = &arg2_str;
9626   arg3 = (Dali::Property::Value *)jarg3;
9627   if (!arg3) {
9628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9629     return 0;
9630   }
9631   {
9632     try {
9633       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
9634     } CALL_CATCH_EXCEPTION(0);
9635   }
9636
9637   jresult = result;
9638
9639   //argout typemap for const std::string&
9640
9641   return jresult;
9642 }
9643
9644
9645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
9646   int jresult ;
9647   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9648   std::string *arg2 = 0 ;
9649   Dali::Property::Value *arg3 = 0 ;
9650   Dali::Property::AccessMode arg4 ;
9651   Dali::Property::Index result;
9652
9653   arg1 = (Dali::Handle *)jarg1;
9654   if (!jarg2) {
9655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9656     return 0;
9657   }
9658   std::string arg2_str(jarg2);
9659   arg2 = &arg2_str;
9660   arg3 = (Dali::Property::Value *)jarg3;
9661   if (!arg3) {
9662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9663     return 0;
9664   }
9665   arg4 = (Dali::Property::AccessMode)jarg4;
9666   {
9667     try {
9668       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
9669     } CALL_CATCH_EXCEPTION(0);
9670   }
9671
9672   jresult = result;
9673
9674   //argout typemap for const std::string&
9675
9676   return jresult;
9677 }
9678
9679
9680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
9681   void * jresult ;
9682   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9683   Dali::Property::Index arg2 ;
9684   Dali::Property::Value result;
9685
9686   arg1 = (Dali::Handle *)jarg1;
9687   arg2 = (Dali::Property::Index)jarg2;
9688   {
9689     try {
9690       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
9691     } CALL_CATCH_EXCEPTION(0);
9692   }
9693
9694   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
9695   return jresult;
9696 }
9697
9698
9699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) {
9700   void * jresult ;
9701   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9702   Dali::Property::Index arg2 ;
9703   Dali::Property::Value result;
9704
9705   arg1 = (Dali::Handle *)jarg1;
9706   arg2 = (Dali::Property::Index)jarg2;
9707   {
9708     try {
9709       result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2);
9710     } CALL_CATCH_EXCEPTION(0);
9711   }
9712
9713   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
9714   return jresult;
9715 }
9716
9717
9718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
9719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9720   Dali::Property::IndexContainer *arg2 = 0 ;
9721
9722   arg1 = (Dali::Handle *)jarg1;
9723   arg2 = (Dali::Property::IndexContainer *)jarg2;
9724   if (!arg2) {
9725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
9726     return ;
9727   }
9728   {
9729     try {
9730       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
9731     } CALL_CATCH_EXCEPTION();
9732   }
9733
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
9738   void * jresult ;
9739   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9740   Dali::Property::Index arg2 ;
9741   Dali::PropertyCondition *arg3 = 0 ;
9742   Dali::PropertyNotification result;
9743
9744   arg1 = (Dali::Handle *)jarg1;
9745   arg2 = (Dali::Property::Index)jarg2;
9746   arg3 = (Dali::PropertyCondition *)jarg3;
9747   if (!arg3) {
9748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
9749     return 0;
9750   }
9751   {
9752     try {
9753       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
9754     } CALL_CATCH_EXCEPTION(0);
9755   }
9756
9757   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9758   return jresult;
9759 }
9760
9761
9762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
9763   void * jresult ;
9764   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9765   Dali::Property::Index arg2 ;
9766   int arg3 ;
9767   Dali::PropertyCondition *arg4 = 0 ;
9768   Dali::PropertyNotification result;
9769
9770   arg1 = (Dali::Handle *)jarg1;
9771   arg2 = (Dali::Property::Index)jarg2;
9772   arg3 = (int)jarg3;
9773   arg4 = (Dali::PropertyCondition *)jarg4;
9774   if (!arg4) {
9775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
9776     return 0;
9777   }
9778   {
9779     try {
9780       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
9781     } CALL_CATCH_EXCEPTION(0);
9782   }
9783
9784   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
9790   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9791   Dali::PropertyNotification arg2 ;
9792   Dali::PropertyNotification *argp2 ;
9793
9794   arg1 = (Dali::Handle *)jarg1;
9795   argp2 = (Dali::PropertyNotification *)jarg2;
9796   if (!argp2) {
9797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
9798     return ;
9799   }
9800   arg2 = *argp2;
9801   {
9802     try {
9803       (arg1)->RemovePropertyNotification(arg2);
9804     } CALL_CATCH_EXCEPTION();
9805   }
9806
9807 }
9808
9809
9810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
9811   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9812
9813   arg1 = (Dali::Handle *)jarg1;
9814   {
9815     try {
9816       (arg1)->RemovePropertyNotifications();
9817     } CALL_CATCH_EXCEPTION();
9818   }
9819
9820 }
9821
9822
9823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
9824   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9825
9826   arg1 = (Dali::Handle *)jarg1;
9827   {
9828     try {
9829       (arg1)->RemoveConstraints();
9830     } CALL_CATCH_EXCEPTION();
9831   }
9832
9833 }
9834
9835
9836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
9837   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9838   unsigned int arg2 ;
9839
9840   arg1 = (Dali::Handle *)jarg1;
9841   arg2 = (unsigned int)jarg2;
9842   {
9843     try {
9844       (arg1)->RemoveConstraints(arg2);
9845     } CALL_CATCH_EXCEPTION();
9846   }
9847
9848 }
9849
9850
9851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
9852   void * jresult ;
9853   Dali::Handle result;
9854
9855   {
9856     try {
9857       result = Dali::WeightObject::New();
9858     } CALL_CATCH_EXCEPTION(0);
9859   }
9860
9861   jresult = new Dali::Handle((const Dali::Handle &)result);
9862   return jresult;
9863 }
9864
9865
9866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
9867   void * jresult ;
9868   Dali::TypeInfo *result = 0 ;
9869
9870   {
9871     try {
9872       result = (Dali::TypeInfo *)new Dali::TypeInfo();
9873     } CALL_CATCH_EXCEPTION(0);
9874   }
9875
9876   jresult = (void *)result;
9877   return jresult;
9878 }
9879
9880
9881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
9882   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9883
9884   arg1 = (Dali::TypeInfo *)jarg1;
9885   {
9886     try {
9887       delete arg1;
9888     } CALL_CATCH_EXCEPTION();
9889   }
9890
9891 }
9892
9893
9894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
9895   void * jresult ;
9896   Dali::TypeInfo *arg1 = 0 ;
9897   Dali::TypeInfo *result = 0 ;
9898
9899   arg1 = (Dali::TypeInfo *)jarg1;
9900   if (!arg1) {
9901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
9902     return 0;
9903   }
9904   {
9905     try {
9906       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
9907     } CALL_CATCH_EXCEPTION(0);
9908   }
9909
9910   jresult = (void *)result;
9911   return jresult;
9912 }
9913
9914
9915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
9916   void * jresult ;
9917   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9918   Dali::TypeInfo *arg2 = 0 ;
9919   Dali::TypeInfo *result = 0 ;
9920
9921   arg1 = (Dali::TypeInfo *)jarg1;
9922   arg2 = (Dali::TypeInfo *)jarg2;
9923   if (!arg2) {
9924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
9925     return 0;
9926   }
9927   {
9928     try {
9929       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
9930     } CALL_CATCH_EXCEPTION(0);
9931   }
9932
9933   jresult = (void *)result;
9934   return jresult;
9935 }
9936
9937
9938 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
9939   char * jresult ;
9940   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9941   std::string *result = 0 ;
9942
9943   arg1 = (Dali::TypeInfo *)jarg1;
9944   {
9945     try {
9946       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
9947     } CALL_CATCH_EXCEPTION(0);
9948   }
9949
9950   jresult = SWIG_csharp_string_callback(result->c_str());
9951   return jresult;
9952 }
9953
9954
9955 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
9956   char * jresult ;
9957   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9958   std::string *result = 0 ;
9959
9960   arg1 = (Dali::TypeInfo *)jarg1;
9961   {
9962     try {
9963       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
9964     } CALL_CATCH_EXCEPTION(0);
9965   }
9966
9967   jresult = SWIG_csharp_string_callback(result->c_str());
9968   return jresult;
9969 }
9970
9971
9972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
9973   void * jresult ;
9974   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9975   Dali::BaseHandle result;
9976
9977   arg1 = (Dali::TypeInfo *)jarg1;
9978   {
9979     try {
9980       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
9981     } CALL_CATCH_EXCEPTION(0);
9982   }
9983
9984   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
9985   return jresult;
9986 }
9987
9988
9989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
9990   unsigned long jresult ;
9991   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9992   size_t result;
9993
9994   arg1 = (Dali::TypeInfo *)jarg1;
9995   {
9996     try {
9997       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
9998     } CALL_CATCH_EXCEPTION(0);
9999   }
10000
10001   jresult = (unsigned long)result;
10002   return jresult;
10003 }
10004
10005
10006 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
10007   char * jresult ;
10008   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10009   size_t arg2 ;
10010   std::string result;
10011
10012   arg1 = (Dali::TypeInfo *)jarg1;
10013   arg2 = (size_t)jarg2;
10014   {
10015     try {
10016       result = (arg1)->GetActionName(arg2);
10017     } CALL_CATCH_EXCEPTION(0);
10018   }
10019
10020   jresult = SWIG_csharp_string_callback((&result)->c_str());
10021   return jresult;
10022 }
10023
10024
10025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
10026   unsigned long jresult ;
10027   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10028   size_t result;
10029
10030   arg1 = (Dali::TypeInfo *)jarg1;
10031   {
10032     try {
10033       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
10034     } CALL_CATCH_EXCEPTION(0);
10035   }
10036
10037   jresult = (unsigned long)result;
10038   return jresult;
10039 }
10040
10041
10042 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
10043   char * jresult ;
10044   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10045   size_t arg2 ;
10046   std::string result;
10047
10048   arg1 = (Dali::TypeInfo *)jarg1;
10049   arg2 = (size_t)jarg2;
10050   {
10051     try {
10052       result = (arg1)->GetSignalName(arg2);
10053     } CALL_CATCH_EXCEPTION(0);
10054   }
10055
10056   jresult = SWIG_csharp_string_callback((&result)->c_str());
10057   return jresult;
10058 }
10059
10060
10061 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
10062   unsigned long jresult ;
10063   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10064   size_t result;
10065
10066   arg1 = (Dali::TypeInfo *)jarg1;
10067   {
10068     try {
10069       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
10070     } CALL_CATCH_EXCEPTION(0);
10071   }
10072
10073   jresult = (unsigned long)result;
10074   return jresult;
10075 }
10076
10077
10078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
10079   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10080   Dali::Property::IndexContainer *arg2 = 0 ;
10081
10082   arg1 = (Dali::TypeInfo *)jarg1;
10083   arg2 = (Dali::Property::IndexContainer *)jarg2;
10084   if (!arg2) {
10085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
10086     return ;
10087   }
10088   {
10089     try {
10090       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
10091     } CALL_CATCH_EXCEPTION();
10092   }
10093
10094 }
10095
10096
10097 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
10098   char * jresult ;
10099   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
10100   Dali::Property::Index arg2 ;
10101   std::string_view result;
10102
10103   arg1 = (Dali::TypeInfo *)jarg1;
10104   arg2 = (Dali::Property::Index)jarg2;
10105   {
10106     try {
10107       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
10108     } CALL_CATCH_EXCEPTION(0);
10109   }
10110
10111   jresult = SWIG_csharp_string_callback(result.data());
10112   return jresult;
10113 }
10114
10115
10116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
10117   void * jresult ;
10118   Dali::TypeRegistry result;
10119
10120   {
10121     try {
10122       result = Dali::TypeRegistry::Get();
10123     } CALL_CATCH_EXCEPTION(0);
10124   }
10125
10126   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
10127   return jresult;
10128 }
10129
10130
10131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
10132   void * jresult ;
10133   Dali::TypeRegistry *result = 0 ;
10134
10135   {
10136     try {
10137       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
10138     } CALL_CATCH_EXCEPTION(0);
10139   }
10140
10141   jresult = (void *)result;
10142   return jresult;
10143 }
10144
10145
10146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
10147   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10148
10149   arg1 = (Dali::TypeRegistry *)jarg1;
10150   {
10151     try {
10152       delete arg1;
10153     } CALL_CATCH_EXCEPTION();
10154   }
10155
10156 }
10157
10158
10159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
10160   void * jresult ;
10161   Dali::TypeRegistry *arg1 = 0 ;
10162   Dali::TypeRegistry *result = 0 ;
10163
10164   arg1 = (Dali::TypeRegistry *)jarg1;
10165   if (!arg1) {
10166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
10167     return 0;
10168   }
10169   {
10170     try {
10171       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
10172     } CALL_CATCH_EXCEPTION(0);
10173   }
10174
10175   jresult = (void *)result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
10181   void * jresult ;
10182   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10183   Dali::TypeRegistry *arg2 = 0 ;
10184   Dali::TypeRegistry *result = 0 ;
10185
10186   arg1 = (Dali::TypeRegistry *)jarg1;
10187   arg2 = (Dali::TypeRegistry *)jarg2;
10188   if (!arg2) {
10189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
10190     return 0;
10191   }
10192   {
10193     try {
10194       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
10195     } CALL_CATCH_EXCEPTION(0);
10196   }
10197
10198   jresult = (void *)result;
10199   return jresult;
10200 }
10201
10202
10203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
10204   void * jresult ;
10205   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10206   std::string *arg2 = 0 ;
10207   Dali::TypeInfo result;
10208
10209   arg1 = (Dali::TypeRegistry *)jarg1;
10210   if (!jarg2) {
10211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10212     return 0;
10213   }
10214   std::string arg2_str(jarg2);
10215   arg2 = &arg2_str;
10216   {
10217     try {
10218       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
10219     } CALL_CATCH_EXCEPTION(0);
10220   }
10221
10222   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
10223
10224   //argout typemap for const std::string&
10225
10226   return jresult;
10227 }
10228
10229
10230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
10231   void * jresult ;
10232   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10233   std::type_info *arg2 = 0 ;
10234   Dali::TypeInfo result;
10235
10236   arg1 = (Dali::TypeRegistry *)jarg1;
10237   arg2 = (std::type_info *)jarg2;
10238   if (!arg2) {
10239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10240     return 0;
10241   }
10242   {
10243     try {
10244       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
10245     } CALL_CATCH_EXCEPTION(0);
10246   }
10247
10248   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
10249   return jresult;
10250 }
10251
10252
10253 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
10254   unsigned long jresult ;
10255   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10256   size_t result;
10257
10258   arg1 = (Dali::TypeRegistry *)jarg1;
10259   {
10260     try {
10261       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
10262     } CALL_CATCH_EXCEPTION(0);
10263   }
10264
10265   jresult = (unsigned long)result;
10266   return jresult;
10267 }
10268
10269
10270 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
10271   char * jresult ;
10272   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
10273   size_t arg2 ;
10274   std::string result;
10275
10276   arg1 = (Dali::TypeRegistry *)jarg1;
10277   arg2 = (size_t)jarg2;
10278   {
10279     try {
10280       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
10281     } CALL_CATCH_EXCEPTION(0);
10282   }
10283
10284   jresult = SWIG_csharp_string_callback((&result)->c_str());
10285   return jresult;
10286 }
10287
10288
10289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
10290   void * jresult ;
10291   std::type_info *arg1 = 0 ;
10292   std::type_info *arg2 = 0 ;
10293   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
10294   Dali::TypeRegistration *result = 0 ;
10295
10296   arg1 = (std::type_info *)jarg1;
10297   if (!arg1) {
10298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10299     return 0;
10300   }
10301   arg2 = (std::type_info *)jarg2;
10302   if (!arg2) {
10303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10304     return 0;
10305   }
10306   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
10307   {
10308     try {
10309       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
10310     } CALL_CATCH_EXCEPTION(0);
10311   }
10312
10313   jresult = (void *)result;
10314   return jresult;
10315 }
10316
10317
10318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
10319   void * jresult ;
10320   std::type_info *arg1 = 0 ;
10321   std::type_info *arg2 = 0 ;
10322   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
10323   bool arg4 ;
10324   Dali::TypeRegistration *result = 0 ;
10325
10326   arg1 = (std::type_info *)jarg1;
10327   if (!arg1) {
10328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10329     return 0;
10330   }
10331   arg2 = (std::type_info *)jarg2;
10332   if (!arg2) {
10333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10334     return 0;
10335   }
10336   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
10337   arg4 = jarg4 ? true : false;
10338   {
10339     try {
10340       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
10341     } CALL_CATCH_EXCEPTION(0);
10342   }
10343
10344   jresult = (void *)result;
10345   return jresult;
10346 }
10347
10348
10349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
10350   void * jresult ;
10351   std::string *arg1 = 0 ;
10352   std::type_info *arg2 = 0 ;
10353   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
10354   Dali::TypeRegistration *result = 0 ;
10355
10356   if (!jarg1) {
10357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10358     return 0;
10359   }
10360   std::string arg1_str(jarg1);
10361   arg1 = &arg1_str;
10362   arg2 = (std::type_info *)jarg2;
10363   if (!arg2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10365     return 0;
10366   }
10367   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
10368   {
10369     try {
10370       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
10371     } CALL_CATCH_EXCEPTION(0);
10372   }
10373
10374   jresult = (void *)result;
10375
10376   //argout typemap for const std::string&
10377
10378   return jresult;
10379 }
10380
10381
10382 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
10383   char * jresult ;
10384   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
10385   std::string result;
10386
10387   arg1 = (Dali::TypeRegistration *)jarg1;
10388   {
10389     try {
10390       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
10391     } CALL_CATCH_EXCEPTION(0);
10392   }
10393
10394   jresult = SWIG_csharp_string_callback((&result)->c_str());
10395   return jresult;
10396 }
10397
10398
10399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
10400   std::string *arg1 = 0 ;
10401   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
10402
10403   if (!jarg1) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10405     return ;
10406   }
10407   std::string arg1_str(jarg1);
10408   arg1 = &arg1_str;
10409   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
10410   {
10411     try {
10412       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
10413     } CALL_CATCH_EXCEPTION();
10414   }
10415
10416
10417   //argout typemap for const std::string&
10418
10419 }
10420
10421
10422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10423   std::string *arg1 = 0 ;
10424   std::string *arg2 = 0 ;
10425   int arg3 ;
10426   Dali::Property::Type arg4 ;
10427   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
10428   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
10429
10430   if (!jarg1) {
10431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10432     return ;
10433   }
10434   std::string arg1_str(jarg1);
10435   arg1 = &arg1_str;
10436   if (!jarg2) {
10437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10438     return ;
10439   }
10440   std::string arg2_str(jarg2);
10441   arg2 = &arg2_str;
10442   arg3 = (int)jarg3;
10443   arg4 = (Dali::Property::Type)jarg4;
10444   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
10445   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
10446   {
10447     try {
10448       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10449     } CALL_CATCH_EXCEPTION();
10450   }
10451
10452
10453   //argout typemap for const std::string&
10454
10455
10456   //argout typemap for const std::string&
10457
10458 }
10459
10460
10461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
10462   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
10463
10464   arg1 = (Dali::TypeRegistration *)jarg1;
10465   {
10466     try {
10467       delete arg1;
10468     } CALL_CATCH_EXCEPTION();
10469   }
10470
10471 }
10472
10473
10474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
10475   void * jresult ;
10476   Dali::TypeRegistration *arg1 = 0 ;
10477   std::string *arg2 = 0 ;
10478   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
10479   Dali::SignalConnectorType *result = 0 ;
10480
10481   arg1 = (Dali::TypeRegistration *)jarg1;
10482   if (!arg1) {
10483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10484     return 0;
10485   }
10486   if (!jarg2) {
10487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10488     return 0;
10489   }
10490   std::string arg2_str(jarg2);
10491   arg2 = &arg2_str;
10492   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
10493   {
10494     try {
10495       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
10496     } CALL_CATCH_EXCEPTION(0);
10497   }
10498
10499   jresult = (void *)result;
10500
10501   //argout typemap for const std::string&
10502
10503   return jresult;
10504 }
10505
10506
10507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
10508   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
10509
10510   arg1 = (Dali::SignalConnectorType *)jarg1;
10511   {
10512     try {
10513       delete arg1;
10514     } CALL_CATCH_EXCEPTION();
10515   }
10516
10517 }
10518
10519
10520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
10521   void * jresult ;
10522   Dali::TypeRegistration *arg1 = 0 ;
10523   std::string *arg2 = 0 ;
10524   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
10525   Dali::TypeAction *result = 0 ;
10526
10527   arg1 = (Dali::TypeRegistration *)jarg1;
10528   if (!arg1) {
10529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10530     return 0;
10531   }
10532   if (!jarg2) {
10533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10534     return 0;
10535   }
10536   std::string arg2_str(jarg2);
10537   arg2 = &arg2_str;
10538   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
10539   {
10540     try {
10541       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
10542     } CALL_CATCH_EXCEPTION(0);
10543   }
10544
10545   jresult = (void *)result;
10546
10547   //argout typemap for const std::string&
10548
10549   return jresult;
10550 }
10551
10552
10553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
10554   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
10555
10556   arg1 = (Dali::TypeAction *)jarg1;
10557   {
10558     try {
10559       delete arg1;
10560     } CALL_CATCH_EXCEPTION();
10561   }
10562
10563 }
10564
10565
10566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10567   void * jresult ;
10568   Dali::TypeRegistration *arg1 = 0 ;
10569   std::string *arg2 = 0 ;
10570   Dali::Property::Index arg3 ;
10571   Dali::Property::Type arg4 ;
10572   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
10573   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
10574   Dali::PropertyRegistration *result = 0 ;
10575
10576   arg1 = (Dali::TypeRegistration *)jarg1;
10577   if (!arg1) {
10578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10579     return 0;
10580   }
10581   if (!jarg2) {
10582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10583     return 0;
10584   }
10585   std::string arg2_str(jarg2);
10586   arg2 = &arg2_str;
10587   arg3 = (Dali::Property::Index)jarg3;
10588   arg4 = (Dali::Property::Type)jarg4;
10589   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
10590   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
10591   {
10592     try {
10593       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10594     } CALL_CATCH_EXCEPTION(0);
10595   }
10596
10597   jresult = (void *)result;
10598
10599   //argout typemap for const std::string&
10600
10601   return jresult;
10602 }
10603
10604
10605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
10606   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
10607
10608   arg1 = (Dali::PropertyRegistration *)jarg1;
10609   {
10610     try {
10611       delete arg1;
10612     } CALL_CATCH_EXCEPTION();
10613   }
10614
10615 }
10616
10617
10618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
10619   void * jresult ;
10620   Dali::TypeRegistration *arg1 = 0 ;
10621   std::string *arg2 = 0 ;
10622   Dali::Property::Index arg3 ;
10623   Dali::Property::Type arg4 ;
10624   Dali::AnimatablePropertyRegistration *result = 0 ;
10625
10626   arg1 = (Dali::TypeRegistration *)jarg1;
10627   if (!arg1) {
10628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10629     return 0;
10630   }
10631   if (!jarg2) {
10632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10633     return 0;
10634   }
10635   std::string arg2_str(jarg2);
10636   arg2 = &arg2_str;
10637   arg3 = (Dali::Property::Index)jarg3;
10638   arg4 = (Dali::Property::Type)jarg4;
10639   {
10640     try {
10641       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
10642     } CALL_CATCH_EXCEPTION(0);
10643   }
10644
10645   jresult = (void *)result;
10646
10647   //argout typemap for const std::string&
10648
10649   return jresult;
10650 }
10651
10652
10653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
10654   void * jresult ;
10655   Dali::TypeRegistration *arg1 = 0 ;
10656   std::string *arg2 = 0 ;
10657   Dali::Property::Index arg3 ;
10658   Dali::Property::Value *arg4 = 0 ;
10659   Dali::AnimatablePropertyRegistration *result = 0 ;
10660
10661   arg1 = (Dali::TypeRegistration *)jarg1;
10662   if (!arg1) {
10663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10664     return 0;
10665   }
10666   if (!jarg2) {
10667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10668     return 0;
10669   }
10670   std::string arg2_str(jarg2);
10671   arg2 = &arg2_str;
10672   arg3 = (Dali::Property::Index)jarg3;
10673   arg4 = (Dali::Property::Value *)jarg4;
10674   if (!arg4) {
10675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10676     return 0;
10677   }
10678   {
10679     try {
10680       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
10681     } CALL_CATCH_EXCEPTION(0);
10682   }
10683
10684   jresult = (void *)result;
10685
10686   //argout typemap for const std::string&
10687
10688   return jresult;
10689 }
10690
10691
10692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
10693   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
10694
10695   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
10696   {
10697     try {
10698       delete arg1;
10699     } CALL_CATCH_EXCEPTION();
10700   }
10701
10702 }
10703
10704
10705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
10706   void * jresult ;
10707   Dali::TypeRegistration *arg1 = 0 ;
10708   std::string *arg2 = 0 ;
10709   Dali::Property::Index arg3 ;
10710   Dali::Property::Index arg4 ;
10711   unsigned int arg5 ;
10712   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
10713
10714   arg1 = (Dali::TypeRegistration *)jarg1;
10715   if (!arg1) {
10716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10717     return 0;
10718   }
10719   if (!jarg2) {
10720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10721     return 0;
10722   }
10723   std::string arg2_str(jarg2);
10724   arg2 = &arg2_str;
10725   arg3 = (Dali::Property::Index)jarg3;
10726   arg4 = (Dali::Property::Index)jarg4;
10727   arg5 = (unsigned int)jarg5;
10728   {
10729     try {
10730       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
10731     } CALL_CATCH_EXCEPTION(0);
10732   }
10733
10734   jresult = (void *)result;
10735
10736   //argout typemap for const std::string&
10737
10738   return jresult;
10739 }
10740
10741
10742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
10743   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
10744
10745   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
10746   {
10747     try {
10748       delete arg1;
10749     } CALL_CATCH_EXCEPTION();
10750   }
10751
10752 }
10753
10754
10755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
10756   void * jresult ;
10757   Dali::TypeRegistration *arg1 = 0 ;
10758   std::string *arg2 = 0 ;
10759   Dali::Property::Index arg3 ;
10760   Dali::Property::Type arg4 ;
10761   Dali::ChildPropertyRegistration *result = 0 ;
10762
10763   arg1 = (Dali::TypeRegistration *)jarg1;
10764   if (!arg1) {
10765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10766     return 0;
10767   }
10768   if (!jarg2) {
10769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10770     return 0;
10771   }
10772   std::string arg2_str(jarg2);
10773   arg2 = &arg2_str;
10774   arg3 = (Dali::Property::Index)jarg3;
10775   arg4 = (Dali::Property::Type)jarg4;
10776   {
10777     try {
10778       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
10779     } CALL_CATCH_EXCEPTION(0);
10780   }
10781
10782   jresult = (void *)result;
10783
10784   //argout typemap for const std::string&
10785
10786   return jresult;
10787 }
10788
10789
10790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
10791   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
10792
10793   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
10794   {
10795     try {
10796       delete arg1;
10797     } CALL_CATCH_EXCEPTION();
10798   }
10799
10800 }
10801
10802
10803 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
10804   bool jresult ;
10805   std::string *arg1 = 0 ;
10806   std::type_info *arg2 = 0 ;
10807   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
10808   bool result;
10809
10810   if (!jarg1) {
10811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10812     return 0;
10813   }
10814   std::string arg1_str(jarg1);
10815   arg1 = &arg1_str;
10816   arg2 = (std::type_info *)jarg2;
10817   if (!arg2) {
10818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10819     return 0;
10820   }
10821   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
10822   {
10823     try {
10824       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
10825     } CALL_CATCH_EXCEPTION(0);
10826   }
10827
10828   jresult = result;
10829
10830   //argout typemap for const std::string&
10831
10832   return jresult;
10833 }
10834
10835
10836 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10837   bool jresult ;
10838   std::string *arg1 = 0 ;
10839   std::string *arg2 = 0 ;
10840   Dali::Property::Index arg3 ;
10841   Dali::Property::Type arg4 ;
10842   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
10843   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
10844   bool result;
10845
10846   if (!jarg1) {
10847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10848     return 0;
10849   }
10850   std::string arg1_str(jarg1);
10851   arg1 = &arg1_str;
10852   if (!jarg2) {
10853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10854     return 0;
10855   }
10856   std::string arg2_str(jarg2);
10857   arg2 = &arg2_str;
10858   arg3 = (Dali::Property::Index)jarg3;
10859   arg4 = (Dali::Property::Type)jarg4;
10860   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
10861   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
10862   {
10863     try {
10864       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10865     } CALL_CATCH_EXCEPTION(0);
10866   }
10867
10868   jresult = result;
10869
10870   //argout typemap for const std::string&
10871
10872
10873   //argout typemap for const std::string&
10874
10875   return jresult;
10876 }
10877
10878
10879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
10880   int jresult ;
10881   Dali::ResizePolicy::Type result;
10882
10883   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
10884   jresult = (int)result;
10885   return jresult;
10886 }
10887
10888
10889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
10890   unsigned long jresult ;
10891   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10892   Dali::VectorBase::SizeType result;
10893
10894   arg1 = (Dali::VectorBase *)jarg1;
10895   {
10896     try {
10897       result = ((Dali::VectorBase const *)arg1)->Count();
10898     } CALL_CATCH_EXCEPTION(0);
10899   }
10900
10901   jresult = (unsigned long)result;
10902   return jresult;
10903 }
10904
10905
10906 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
10907   unsigned long jresult ;
10908   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10909   Dali::VectorBase::SizeType result;
10910
10911   arg1 = (Dali::VectorBase *)jarg1;
10912   {
10913     try {
10914       result = ((Dali::VectorBase const *)arg1)->Size();
10915     } CALL_CATCH_EXCEPTION(0);
10916   }
10917
10918   jresult = (unsigned long)result;
10919   return jresult;
10920 }
10921
10922
10923 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
10924   bool jresult ;
10925   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10926   bool result;
10927
10928   arg1 = (Dali::VectorBase *)jarg1;
10929   {
10930     try {
10931       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
10932     } CALL_CATCH_EXCEPTION(0);
10933   }
10934
10935   jresult = result;
10936   return jresult;
10937 }
10938
10939
10940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
10941   unsigned long jresult ;
10942   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10943   Dali::VectorBase::SizeType result;
10944
10945   arg1 = (Dali::VectorBase *)jarg1;
10946   {
10947     try {
10948       result = ((Dali::VectorBase const *)arg1)->Capacity();
10949     } CALL_CATCH_EXCEPTION(0);
10950   }
10951
10952   jresult = (unsigned long)result;
10953   return jresult;
10954 }
10955
10956
10957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
10958   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10959
10960   arg1 = (Dali::VectorBase *)jarg1;
10961   {
10962     try {
10963       (arg1)->Release();
10964     } CALL_CATCH_EXCEPTION();
10965   }
10966
10967 }
10968
10969
10970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
10971   int jresult ;
10972   Dali::Pixel::Format result;
10973
10974   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
10975   jresult = (int)result;
10976   return jresult;
10977 }
10978
10979
10980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
10981   int jresult ;
10982   Dali::Pixel::Format result;
10983
10984   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
10985   jresult = (int)result;
10986   return jresult;
10987 }
10988
10989
10990 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
10991   bool jresult ;
10992   Dali::Pixel::Format arg1 ;
10993   bool result;
10994
10995   arg1 = (Dali::Pixel::Format)jarg1;
10996   {
10997     try {
10998       result = (bool)Dali::Pixel::HasAlpha(arg1);
10999     } CALL_CATCH_EXCEPTION(0);
11000   }
11001
11002   jresult = result;
11003   return jresult;
11004 }
11005
11006
11007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
11008   unsigned int jresult ;
11009   Dali::Pixel::Format arg1 ;
11010   unsigned int result;
11011
11012   arg1 = (Dali::Pixel::Format)jarg1;
11013   {
11014     try {
11015       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
11016     } CALL_CATCH_EXCEPTION(0);
11017   }
11018
11019   jresult = result;
11020   return jresult;
11021 }
11022
11023
11024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
11025   Dali::Pixel::Format arg1 ;
11026   int *arg2 = 0 ;
11027   int *arg3 = 0 ;
11028
11029   arg1 = (Dali::Pixel::Format)jarg1;
11030   arg2 = (int *)jarg2;
11031   if (!arg2) {
11032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
11033     return ;
11034   }
11035   arg3 = (int *)jarg3;
11036   if (!arg3) {
11037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
11038     return ;
11039   }
11040   {
11041     try {
11042       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
11043     } CALL_CATCH_EXCEPTION();
11044   }
11045
11046 }
11047
11048
11049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
11050   void * jresult ;
11051   Dali::PixelData result;
11052
11053   {
11054     unsigned char* copiedBuffer;
11055     try
11056     {
11057       copiedBuffer = new unsigned char[nuiBufferSize];
11058     } CALL_CATCH_EXCEPTION(0);
11059
11060     try
11061     {
11062       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
11063       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
11064       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
11065     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
11066   }
11067
11068   jresult = new Dali::PixelData((const Dali::PixelData &)result);
11069
11070   return jresult;
11071 }
11072
11073
11074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
11075   void * jresult ;
11076   Dali::PixelData *result = 0 ;
11077
11078   {
11079     try {
11080       result = (Dali::PixelData *)new Dali::PixelData();
11081     } CALL_CATCH_EXCEPTION(0);
11082   }
11083
11084   jresult = (void *)result;
11085   return jresult;
11086 }
11087
11088
11089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
11090   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11091
11092   pixelData = (Dali::PixelData *)nuiHandle;
11093   {
11094     try {
11095       delete pixelData;
11096     } CALL_CATCH_EXCEPTION();
11097   }
11098
11099 }
11100
11101
11102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
11103   void * jresult ;
11104   Dali::PixelData *pixelData = 0 ;
11105   Dali::PixelData *result = 0 ;
11106
11107   pixelData = (Dali::PixelData *)nuiHandle;
11108   if (!pixelData) {
11109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
11110     return 0;
11111   }
11112   {
11113     try {
11114       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
11115     } CALL_CATCH_EXCEPTION(0);
11116   }
11117
11118   jresult = (void *)result;
11119   return jresult;
11120 }
11121
11122
11123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
11124   void * jresult ;
11125   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11126   Dali::PixelData *pixelDataSource = 0 ;
11127   Dali::PixelData *result = 0 ;
11128
11129   pixelData = (Dali::PixelData *)nuiHandle;
11130   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
11131   if (!pixelDataSource) {
11132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
11133     return 0;
11134   }
11135   {
11136     try {
11137       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
11138     } CALL_CATCH_EXCEPTION(0);
11139   }
11140
11141   jresult = (void *)result;
11142   return jresult;
11143 }
11144
11145
11146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
11147   unsigned int jresult ;
11148   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11149   unsigned int result;
11150
11151   pixelData = (Dali::PixelData *)nuiHandle;
11152   {
11153     try {
11154       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
11155     } CALL_CATCH_EXCEPTION(0);
11156   }
11157
11158   jresult = result;
11159   return jresult;
11160 }
11161
11162
11163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
11164   unsigned int jresult ;
11165   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11166   unsigned int result;
11167
11168   pixelData = (Dali::PixelData *)nuiHandle;
11169   {
11170     try {
11171       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
11172     } CALL_CATCH_EXCEPTION(0);
11173   }
11174
11175   jresult = result;
11176   return jresult;
11177 }
11178
11179
11180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
11181   int jresult ;
11182   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
11183   Dali::Pixel::Format result;
11184
11185   pixelData = (Dali::PixelData *)nuiHandle;
11186   {
11187     try {
11188       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
11189     } CALL_CATCH_EXCEPTION(0);
11190   }
11191
11192   jresult = (int)result;
11193   return jresult;
11194 }
11195
11196 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
11197 {
11198   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
11199   Dali::Toolkit::ImageUrl result;
11200   void *jresult;
11201
11202   if (!pixelData)
11203   {
11204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
11205     return 0;
11206   }
11207   {
11208     try
11209     {
11210       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
11211     } CALL_CATCH_EXCEPTION(0);
11212   }
11213
11214   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
11215   return jresult;
11216 }
11217
11218
11219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
11220   unsigned int jresult ;
11221   unsigned int result;
11222
11223   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
11224   jresult = result;
11225   return jresult;
11226 }
11227
11228
11229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
11230   unsigned int jresult ;
11231   unsigned int result;
11232
11233   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
11234   jresult = result;
11235   return jresult;
11236 }
11237
11238
11239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
11240   unsigned int jresult ;
11241   unsigned int result;
11242
11243   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
11244   jresult = result;
11245   return jresult;
11246 }
11247
11248
11249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
11250   unsigned int jresult ;
11251   unsigned int result;
11252
11253   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
11254   jresult = result;
11255   return jresult;
11256 }
11257
11258
11259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
11260   unsigned int jresult ;
11261   unsigned int result;
11262
11263   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
11264   jresult = result;
11265   return jresult;
11266 }
11267
11268
11269 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
11270   unsigned int jresult ;
11271   unsigned int result;
11272
11273   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
11274   jresult = result;
11275   return jresult;
11276 }
11277
11278
11279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
11280   void * jresult ;
11281   Dali::TextureType::Type arg1 ;
11282   Dali::Pixel::Format arg2 ;
11283   unsigned int arg3 ;
11284   unsigned int arg4 ;
11285   Dali::Texture result;
11286
11287   arg1 = (Dali::TextureType::Type)jarg1;
11288   arg2 = (Dali::Pixel::Format)jarg2;
11289   arg3 = (unsigned int)jarg3;
11290   arg4 = (unsigned int)jarg4;
11291   {
11292     try {
11293       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
11294     } CALL_CATCH_EXCEPTION(0);
11295   }
11296
11297   jresult = new Dali::Texture((const Dali::Texture &)result);
11298   return jresult;
11299 }
11300
11301
11302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
11303   void * jresult ;
11304   NativeImageInterface *arg1 = 0 ;
11305   Dali::Texture result;
11306
11307   arg1 = (NativeImageInterface *)jarg1;
11308   if (!arg1) {
11309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
11310     return 0;
11311   }
11312   {
11313     try {
11314       result = Dali::Texture::New(*arg1);
11315     } CALL_CATCH_EXCEPTION(0);
11316   }
11317
11318   jresult = new Dali::Texture((const Dali::Texture &)result);
11319   return jresult;
11320 }
11321
11322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
11323   void * jresult ;
11324   Dali::Texture *result = 0 ;
11325
11326   {
11327     try {
11328       result = (Dali::Texture *)new Dali::Texture();
11329     } CALL_CATCH_EXCEPTION(0);
11330   }
11331
11332   jresult = (void *)result;
11333   return jresult;
11334 }
11335
11336
11337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
11338   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11339
11340   arg1 = (Dali::Texture *)jarg1;
11341   {
11342     try {
11343       delete arg1;
11344     } CALL_CATCH_EXCEPTION();
11345   }
11346
11347 }
11348
11349
11350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
11351   void * jresult ;
11352   Dali::Texture *arg1 = 0 ;
11353   Dali::Texture *result = 0 ;
11354
11355   arg1 = (Dali::Texture *)jarg1;
11356   if (!arg1) {
11357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
11358     return 0;
11359   }
11360   {
11361     try {
11362       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
11363     } CALL_CATCH_EXCEPTION(0);
11364   }
11365
11366   jresult = (void *)result;
11367   return jresult;
11368 }
11369
11370
11371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
11372   void * jresult ;
11373   Dali::BaseHandle arg1 ;
11374   Dali::BaseHandle *argp1 ;
11375   Dali::Texture result;
11376
11377   argp1 = (Dali::BaseHandle *)jarg1;
11378   if (!argp1) {
11379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11380     return 0;
11381   }
11382   arg1 = *argp1;
11383   {
11384     try {
11385       result = Dali::Texture::DownCast(arg1);
11386     } CALL_CATCH_EXCEPTION(0);
11387   }
11388
11389   jresult = new Dali::Texture((const Dali::Texture &)result);
11390   return jresult;
11391 }
11392
11393
11394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
11395   void * jresult ;
11396   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11397   Dali::Texture *arg2 = 0 ;
11398   Dali::Texture *result = 0 ;
11399
11400   arg1 = (Dali::Texture *)jarg1;
11401   arg2 = (Dali::Texture *)jarg2;
11402   if (!arg2) {
11403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
11404     return 0;
11405   }
11406   {
11407     try {
11408       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
11409     } CALL_CATCH_EXCEPTION(0);
11410   }
11411
11412   jresult = (void *)result;
11413   return jresult;
11414 }
11415
11416
11417 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
11418   bool jresult ;
11419   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11420   Dali::PixelData arg2 ;
11421   Dali::PixelData *argp2 ;
11422   bool result;
11423
11424   arg1 = (Dali::Texture *)jarg1;
11425   argp2 = (Dali::PixelData *)jarg2;
11426   if (!argp2) {
11427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
11428     return 0;
11429   }
11430   arg2 = *argp2;
11431   {
11432     try {
11433       result = (bool)(arg1)->Upload(arg2);
11434     } CALL_CATCH_EXCEPTION(0);
11435   }
11436
11437   jresult = result;
11438   return jresult;
11439 }
11440
11441
11442 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) {
11443   bool jresult ;
11444   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11445   Dali::PixelData arg2 ;
11446   unsigned int arg3 ;
11447   unsigned int arg4 ;
11448   unsigned int arg5 ;
11449   unsigned int arg6 ;
11450   unsigned int arg7 ;
11451   unsigned int arg8 ;
11452   Dali::PixelData *argp2 ;
11453   bool result;
11454
11455   arg1 = (Dali::Texture *)jarg1;
11456   argp2 = (Dali::PixelData *)jarg2;
11457   if (!argp2) {
11458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
11459     return 0;
11460   }
11461   arg2 = *argp2;
11462   arg3 = (unsigned int)jarg3;
11463   arg4 = (unsigned int)jarg4;
11464   arg5 = (unsigned int)jarg5;
11465   arg6 = (unsigned int)jarg6;
11466   arg7 = (unsigned int)jarg7;
11467   arg8 = (unsigned int)jarg8;
11468   {
11469     try {
11470       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11471     } CALL_CATCH_EXCEPTION(0);
11472   }
11473
11474   jresult = result;
11475   return jresult;
11476 }
11477
11478
11479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
11480   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11481
11482   arg1 = (Dali::Texture *)jarg1;
11483   {
11484     try {
11485       (arg1)->GenerateMipmaps();
11486     } CALL_CATCH_EXCEPTION();
11487   }
11488
11489 }
11490
11491
11492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
11493   unsigned int jresult ;
11494   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11495   unsigned int result;
11496
11497   arg1 = (Dali::Texture *)jarg1;
11498   {
11499     try {
11500       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
11501     } CALL_CATCH_EXCEPTION(0);
11502   }
11503
11504   jresult = result;
11505   return jresult;
11506 }
11507
11508
11509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
11510   unsigned int jresult ;
11511   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11512   unsigned int result;
11513
11514   arg1 = (Dali::Texture *)jarg1;
11515   {
11516     try {
11517       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
11518     } CALL_CATCH_EXCEPTION(0);
11519   }
11520
11521   jresult = result;
11522   return jresult;
11523 }
11524
11525
11526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
11527   void * jresult ;
11528   Dali::Sampler result;
11529
11530   {
11531     try {
11532       result = Dali::Sampler::New();
11533     } CALL_CATCH_EXCEPTION(0);
11534   }
11535
11536   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11537   return jresult;
11538 }
11539
11540
11541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
11542   void * jresult ;
11543   Dali::Sampler *result = 0 ;
11544
11545   {
11546     try {
11547       result = (Dali::Sampler *)new Dali::Sampler();
11548     } CALL_CATCH_EXCEPTION(0);
11549   }
11550
11551   jresult = (void *)result;
11552   return jresult;
11553 }
11554
11555
11556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
11557   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11558
11559   arg1 = (Dali::Sampler *)jarg1;
11560   {
11561     try {
11562       delete arg1;
11563     } CALL_CATCH_EXCEPTION();
11564   }
11565
11566 }
11567
11568
11569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
11570   void * jresult ;
11571   Dali::Sampler *arg1 = 0 ;
11572   Dali::Sampler *result = 0 ;
11573
11574   arg1 = (Dali::Sampler *)jarg1;
11575   if (!arg1) {
11576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
11577     return 0;
11578   }
11579   {
11580     try {
11581       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
11582     } CALL_CATCH_EXCEPTION(0);
11583   }
11584
11585   jresult = (void *)result;
11586   return jresult;
11587 }
11588
11589
11590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
11591   void * jresult ;
11592   Dali::BaseHandle arg1 ;
11593   Dali::BaseHandle *argp1 ;
11594   Dali::Sampler result;
11595
11596   argp1 = (Dali::BaseHandle *)jarg1;
11597   if (!argp1) {
11598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11599     return 0;
11600   }
11601   arg1 = *argp1;
11602   {
11603     try {
11604       result = Dali::Sampler::DownCast(arg1);
11605     } CALL_CATCH_EXCEPTION(0);
11606   }
11607
11608   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11609   return jresult;
11610 }
11611
11612
11613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
11614   void * jresult ;
11615   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11616   Dali::Sampler *arg2 = 0 ;
11617   Dali::Sampler *result = 0 ;
11618
11619   arg1 = (Dali::Sampler *)jarg1;
11620   arg2 = (Dali::Sampler *)jarg2;
11621   if (!arg2) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
11623     return 0;
11624   }
11625   {
11626     try {
11627       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
11628     } CALL_CATCH_EXCEPTION(0);
11629   }
11630
11631   jresult = (void *)result;
11632   return jresult;
11633 }
11634
11635
11636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
11637   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11638   Dali::FilterMode::Type arg2 ;
11639   Dali::FilterMode::Type arg3 ;
11640
11641   arg1 = (Dali::Sampler *)jarg1;
11642   arg2 = (Dali::FilterMode::Type)jarg2;
11643   arg3 = (Dali::FilterMode::Type)jarg3;
11644   {
11645     try {
11646       (arg1)->SetFilterMode(arg2,arg3);
11647     } CALL_CATCH_EXCEPTION();
11648   }
11649
11650 }
11651
11652
11653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
11654   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11655   Dali::WrapMode::Type arg2 ;
11656   Dali::WrapMode::Type arg3 ;
11657
11658   arg1 = (Dali::Sampler *)jarg1;
11659   arg2 = (Dali::WrapMode::Type)jarg2;
11660   arg3 = (Dali::WrapMode::Type)jarg3;
11661   {
11662     try {
11663       (arg1)->SetWrapMode(arg2,arg3);
11664     } CALL_CATCH_EXCEPTION();
11665   }
11666
11667 }
11668
11669
11670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
11671   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11672   Dali::WrapMode::Type arg2 ;
11673   Dali::WrapMode::Type arg3 ;
11674   Dali::WrapMode::Type arg4 ;
11675
11676   arg1 = (Dali::Sampler *)jarg1;
11677   arg2 = (Dali::WrapMode::Type)jarg2;
11678   arg3 = (Dali::WrapMode::Type)jarg3;
11679   arg4 = (Dali::WrapMode::Type)jarg4;
11680   {
11681     try {
11682       (arg1)->SetWrapMode(arg2,arg3,arg4);
11683     } CALL_CATCH_EXCEPTION();
11684   }
11685
11686 }
11687
11688
11689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
11690   void * jresult ;
11691   Dali::TextureSet result;
11692
11693   {
11694     try {
11695       result = Dali::TextureSet::New();
11696     } CALL_CATCH_EXCEPTION(0);
11697   }
11698
11699   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
11700   return jresult;
11701 }
11702
11703
11704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
11705   void * jresult ;
11706   Dali::TextureSet *result = 0 ;
11707
11708   {
11709     try {
11710       result = (Dali::TextureSet *)new Dali::TextureSet();
11711     } CALL_CATCH_EXCEPTION(0);
11712   }
11713
11714   jresult = (void *)result;
11715   return jresult;
11716 }
11717
11718
11719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
11720   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11721
11722   arg1 = (Dali::TextureSet *)jarg1;
11723   {
11724     try {
11725       delete arg1;
11726     } CALL_CATCH_EXCEPTION();
11727   }
11728
11729 }
11730
11731
11732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
11733   void * jresult ;
11734   Dali::TextureSet *arg1 = 0 ;
11735   Dali::TextureSet *result = 0 ;
11736
11737   arg1 = (Dali::TextureSet *)jarg1;
11738   if (!arg1) {
11739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
11740     return 0;
11741   }
11742   {
11743     try {
11744       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
11745     } CALL_CATCH_EXCEPTION(0);
11746   }
11747
11748   jresult = (void *)result;
11749   return jresult;
11750 }
11751
11752
11753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
11754   void * jresult ;
11755   Dali::BaseHandle arg1 ;
11756   Dali::BaseHandle *argp1 ;
11757   Dali::TextureSet result;
11758
11759   argp1 = (Dali::BaseHandle *)jarg1;
11760   if (!argp1) {
11761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11762     return 0;
11763   }
11764   arg1 = *argp1;
11765   {
11766     try {
11767       result = Dali::TextureSet::DownCast(arg1);
11768     } CALL_CATCH_EXCEPTION(0);
11769   }
11770
11771   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
11772   return jresult;
11773 }
11774
11775
11776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
11777   void * jresult ;
11778   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11779   Dali::TextureSet *arg2 = 0 ;
11780   Dali::TextureSet *result = 0 ;
11781
11782   arg1 = (Dali::TextureSet *)jarg1;
11783   arg2 = (Dali::TextureSet *)jarg2;
11784   if (!arg2) {
11785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
11786     return 0;
11787   }
11788   {
11789     try {
11790       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
11791     } CALL_CATCH_EXCEPTION(0);
11792   }
11793
11794   jresult = (void *)result;
11795   return jresult;
11796 }
11797
11798
11799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
11800   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11801   size_t arg2 ;
11802   Dali::Texture arg3 ;
11803   Dali::Texture *argp3 ;
11804
11805   arg1 = (Dali::TextureSet *)jarg1;
11806   arg2 = (size_t)jarg2;
11807   argp3 = (Dali::Texture *)jarg3;
11808   if (!argp3) {
11809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
11810     return ;
11811   }
11812   arg3 = *argp3;
11813   {
11814     try {
11815       (arg1)->SetTexture(arg2,arg3);
11816     } CALL_CATCH_EXCEPTION();
11817   }
11818
11819 }
11820
11821
11822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
11823   void * jresult ;
11824   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11825   size_t arg2 ;
11826   Dali::Texture result;
11827
11828   arg1 = (Dali::TextureSet *)jarg1;
11829   arg2 = (size_t)jarg2;
11830   {
11831     try {
11832       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
11833     } CALL_CATCH_EXCEPTION(0);
11834   }
11835
11836   jresult = new Dali::Texture((const Dali::Texture &)result);
11837   return jresult;
11838 }
11839
11840
11841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
11842   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11843   size_t arg2 ;
11844   Dali::Sampler arg3 ;
11845   Dali::Sampler *argp3 ;
11846
11847   arg1 = (Dali::TextureSet *)jarg1;
11848   arg2 = (size_t)jarg2;
11849   argp3 = (Dali::Sampler *)jarg3;
11850   if (!argp3) {
11851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
11852     return ;
11853   }
11854   arg3 = *argp3;
11855   {
11856     try {
11857       (arg1)->SetSampler(arg2,arg3);
11858     } CALL_CATCH_EXCEPTION();
11859   }
11860
11861 }
11862
11863
11864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
11865   void * jresult ;
11866   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11867   size_t arg2 ;
11868   Dali::Sampler result;
11869
11870   arg1 = (Dali::TextureSet *)jarg1;
11871   arg2 = (size_t)jarg2;
11872   {
11873     try {
11874       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
11875     } CALL_CATCH_EXCEPTION(0);
11876   }
11877
11878   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11879   return jresult;
11880 }
11881
11882
11883 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
11884   unsigned long jresult ;
11885   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11886   size_t result;
11887
11888   arg1 = (Dali::TextureSet *)jarg1;
11889   {
11890     try {
11891       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
11892     } CALL_CATCH_EXCEPTION(0);
11893   }
11894
11895   jresult = (unsigned long)result;
11896   return jresult;
11897 }
11898
11899
11900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
11901   void * jresult ;
11902   Dali::Property::Map *arg1 = 0 ;
11903   Dali::VertexBuffer result;
11904
11905   arg1 = (Dali::Property::Map *)jarg1;
11906   if (!arg1) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11908     return 0;
11909   }
11910   {
11911     try {
11912       result = Dali::VertexBuffer::New(*arg1);
11913     } CALL_CATCH_EXCEPTION(0);
11914   }
11915
11916   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
11917   return jresult;
11918 }
11919
11920
11921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
11922   void * jresult ;
11923   Dali::VertexBuffer *result = 0 ;
11924
11925   {
11926     try {
11927       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
11928     } CALL_CATCH_EXCEPTION(0);
11929   }
11930
11931   jresult = (void *)result;
11932   return jresult;
11933 }
11934
11935
11936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
11937   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11938
11939   arg1 = (Dali::VertexBuffer *)jarg1;
11940   {
11941     try {
11942       delete arg1;
11943     } CALL_CATCH_EXCEPTION();
11944   }
11945
11946 }
11947
11948
11949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
11950   void * jresult ;
11951   Dali::VertexBuffer *arg1 = 0 ;
11952   Dali::VertexBuffer *result = 0 ;
11953
11954   arg1 = (Dali::VertexBuffer *)jarg1;
11955   if (!arg1) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
11957     return 0;
11958   }
11959   {
11960     try {
11961       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
11962     } CALL_CATCH_EXCEPTION(0);
11963   }
11964
11965   jresult = (void *)result;
11966   return jresult;
11967 }
11968
11969
11970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
11971   void * jresult ;
11972   Dali::BaseHandle arg1 ;
11973   Dali::BaseHandle *argp1 ;
11974   Dali::VertexBuffer result;
11975
11976   argp1 = (Dali::BaseHandle *)jarg1;
11977   if (!argp1) {
11978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11979     return 0;
11980   }
11981   arg1 = *argp1;
11982   {
11983     try {
11984       result = Dali::VertexBuffer::DownCast(arg1);
11985     } CALL_CATCH_EXCEPTION(0);
11986   }
11987
11988   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
11989   return jresult;
11990 }
11991
11992
11993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
11994   void * jresult ;
11995   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11996   Dali::VertexBuffer *arg2 = 0 ;
11997   Dali::VertexBuffer *result = 0 ;
11998
11999   arg1 = (Dali::VertexBuffer *)jarg1;
12000   arg2 = (Dali::VertexBuffer *)jarg2;
12001   if (!arg2) {
12002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
12003     return 0;
12004   }
12005   {
12006     try {
12007       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
12008     } CALL_CATCH_EXCEPTION(0);
12009   }
12010
12011   jresult = (void *)result;
12012   return jresult;
12013 }
12014
12015
12016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
12017   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
12018   void *arg2 = (void *) 0 ;
12019   std::size_t arg3 ;
12020
12021   arg1 = (Dali::VertexBuffer *)jarg1;
12022   arg2 = jarg2;
12023   arg3 = (std::size_t)jarg3;
12024   {
12025     try {
12026       (arg1)->SetData((void const *)arg2,arg3);
12027     } CALL_CATCH_EXCEPTION();
12028   }
12029
12030 }
12031
12032
12033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
12034   unsigned long jresult ;
12035   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
12036   std::size_t result;
12037
12038   arg1 = (Dali::VertexBuffer *)jarg1;
12039   {
12040     try {
12041       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
12042     } CALL_CATCH_EXCEPTION(0);
12043   }
12044
12045   jresult = (unsigned long)result;
12046   return jresult;
12047 }
12048
12049
12050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
12051   void * jresult ;
12052   Dali::Geometry result;
12053
12054   {
12055     try {
12056       result = Dali::Geometry::New();
12057     } CALL_CATCH_EXCEPTION(0);
12058   }
12059
12060   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12061   return jresult;
12062 }
12063
12064
12065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
12066   void * jresult ;
12067   Dali::Geometry *result = 0 ;
12068
12069   {
12070     try {
12071       result = (Dali::Geometry *)new Dali::Geometry();
12072     } CALL_CATCH_EXCEPTION(0);
12073   }
12074
12075   jresult = (void *)result;
12076   return jresult;
12077 }
12078
12079
12080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
12081   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12082
12083   arg1 = (Dali::Geometry *)jarg1;
12084   {
12085     try {
12086       delete arg1;
12087     } CALL_CATCH_EXCEPTION();
12088   }
12089
12090 }
12091
12092
12093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
12094   void * jresult ;
12095   Dali::Geometry *arg1 = 0 ;
12096   Dali::Geometry *result = 0 ;
12097
12098   arg1 = (Dali::Geometry *)jarg1;
12099   if (!arg1) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
12101     return 0;
12102   }
12103   {
12104     try {
12105       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
12106     } CALL_CATCH_EXCEPTION(0);
12107   }
12108
12109   jresult = (void *)result;
12110   return jresult;
12111 }
12112
12113
12114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
12115   void * jresult ;
12116   Dali::BaseHandle arg1 ;
12117   Dali::BaseHandle *argp1 ;
12118   Dali::Geometry result;
12119
12120   argp1 = (Dali::BaseHandle *)jarg1;
12121   if (!argp1) {
12122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12123     return 0;
12124   }
12125   arg1 = *argp1;
12126   {
12127     try {
12128       result = Dali::Geometry::DownCast(arg1);
12129     } CALL_CATCH_EXCEPTION(0);
12130   }
12131
12132   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12133   return jresult;
12134 }
12135
12136
12137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
12138   void * jresult ;
12139   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12140   Dali::Geometry *arg2 = 0 ;
12141   Dali::Geometry *result = 0 ;
12142
12143   arg1 = (Dali::Geometry *)jarg1;
12144   arg2 = (Dali::Geometry *)jarg2;
12145   if (!arg2) {
12146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
12147     return 0;
12148   }
12149   {
12150     try {
12151       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
12152     } CALL_CATCH_EXCEPTION(0);
12153   }
12154
12155   jresult = (void *)result;
12156   return jresult;
12157 }
12158
12159
12160 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
12161   unsigned long jresult ;
12162   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12163   Dali::VertexBuffer *arg2 = 0 ;
12164   std::size_t result;
12165
12166   arg1 = (Dali::Geometry *)jarg1;
12167   arg2 = (Dali::VertexBuffer *)jarg2;
12168   if (!arg2) {
12169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
12170     return 0;
12171   }
12172   {
12173     try {
12174       result = (arg1)->AddVertexBuffer(*arg2);
12175     } CALL_CATCH_EXCEPTION(0);
12176   }
12177
12178   jresult = (unsigned long)result;
12179   return jresult;
12180 }
12181
12182
12183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
12184   unsigned long jresult ;
12185   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12186   std::size_t result;
12187
12188   arg1 = (Dali::Geometry *)jarg1;
12189   {
12190     try {
12191       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
12192     } CALL_CATCH_EXCEPTION(0);
12193   }
12194
12195   jresult = (unsigned long)result;
12196   return jresult;
12197 }
12198
12199
12200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
12201   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12202   std::size_t arg2 ;
12203
12204   arg1 = (Dali::Geometry *)jarg1;
12205   arg2 = (std::size_t)jarg2;
12206   {
12207     try {
12208       (arg1)->RemoveVertexBuffer(arg2);
12209     } CALL_CATCH_EXCEPTION();
12210   }
12211
12212 }
12213
12214
12215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
12216   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12217   unsigned short *arg2 = (unsigned short *) 0 ;
12218   size_t arg3 ;
12219
12220   arg1 = (Dali::Geometry *)jarg1;
12221   arg2 = jarg2;
12222   arg3 = (size_t)jarg3;
12223   {
12224     try {
12225       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
12226     } CALL_CATCH_EXCEPTION();
12227   }
12228
12229
12230
12231 }
12232
12233
12234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
12235   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12236   Dali::Geometry::Type arg2 ;
12237
12238   arg1 = (Dali::Geometry *)jarg1;
12239   arg2 = (Dali::Geometry::Type)jarg2;
12240   {
12241     try {
12242       (arg1)->SetType(arg2);
12243     } CALL_CATCH_EXCEPTION();
12244   }
12245
12246 }
12247
12248
12249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
12250   int jresult ;
12251   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
12252   Dali::Geometry::Type result;
12253
12254   arg1 = (Dali::Geometry *)jarg1;
12255   {
12256     try {
12257       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
12258     } CALL_CATCH_EXCEPTION(0);
12259   }
12260
12261   jresult = (int)result;
12262   return jresult;
12263 }
12264
12265
12266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
12267   void * jresult ;
12268   Dali::Shader::Hint *result = 0 ;
12269
12270   {
12271     try {
12272       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
12273     } CALL_CATCH_EXCEPTION(0);
12274   }
12275
12276   jresult = (void *)result;
12277   return jresult;
12278 }
12279
12280
12281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
12282   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
12283
12284   arg1 = (Dali::Shader::Hint *)jarg1;
12285   {
12286     try {
12287       delete arg1;
12288     } CALL_CATCH_EXCEPTION();
12289   }
12290
12291 }
12292
12293
12294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
12295   int jresult ;
12296   int result;
12297
12298   result = (int)Dali::Shader::Property::PROGRAM;
12299   jresult = (int)result;
12300   return jresult;
12301 }
12302
12303
12304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
12305   void * jresult ;
12306   Dali::Shader::Property *result = 0 ;
12307
12308   {
12309     try {
12310       result = (Dali::Shader::Property *)new Dali::Shader::Property();
12311     } CALL_CATCH_EXCEPTION(0);
12312   }
12313
12314   jresult = (void *)result;
12315   return jresult;
12316 }
12317
12318
12319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
12320   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
12321
12322   arg1 = (Dali::Shader::Property *)jarg1;
12323   {
12324     try {
12325       delete arg1;
12326     } CALL_CATCH_EXCEPTION();
12327   }
12328
12329 }
12330
12331
12332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
12333   void * jresult ;
12334   std::string *arg1 = 0 ;
12335   std::string *arg2 = 0 ;
12336   Dali::Shader::Hint::Value arg3 ;
12337   Dali::Shader result;
12338
12339   if (!jarg1) {
12340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12341     return 0;
12342   }
12343   std::string arg1_str(jarg1);
12344   arg1 = &arg1_str;
12345   if (!jarg2) {
12346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12347     return 0;
12348   }
12349   std::string arg2_str(jarg2);
12350   arg2 = &arg2_str;
12351   arg3 = (Dali::Shader::Hint::Value)jarg3;
12352   {
12353     try {
12354       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
12355     } CALL_CATCH_EXCEPTION(0);
12356   }
12357
12358   jresult = new Dali::Shader((const Dali::Shader &)result);
12359
12360   //argout typemap for const std::string&
12361
12362
12363   //argout typemap for const std::string&
12364
12365   return jresult;
12366 }
12367
12368
12369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
12370   void * jresult ;
12371   std::string *arg1 = 0 ;
12372   std::string *arg2 = 0 ;
12373   Dali::Shader result;
12374
12375   if (!jarg1) {
12376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12377     return 0;
12378   }
12379   std::string arg1_str(jarg1);
12380   arg1 = &arg1_str;
12381   if (!jarg2) {
12382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
12383     return 0;
12384   }
12385   std::string arg2_str(jarg2);
12386   arg2 = &arg2_str;
12387   {
12388     try {
12389       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
12390     } CALL_CATCH_EXCEPTION(0);
12391   }
12392
12393   jresult = new Dali::Shader((const Dali::Shader &)result);
12394
12395   //argout typemap for const std::string&
12396
12397
12398   //argout typemap for const std::string&
12399
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
12405   void * jresult ;
12406   Dali::Shader *result = 0 ;
12407
12408   {
12409     try {
12410       result = (Dali::Shader *)new Dali::Shader();
12411     } CALL_CATCH_EXCEPTION(0);
12412   }
12413
12414   jresult = (void *)result;
12415   return jresult;
12416 }
12417
12418
12419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
12420   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
12421
12422   arg1 = (Dali::Shader *)jarg1;
12423   {
12424     try {
12425       delete arg1;
12426     } CALL_CATCH_EXCEPTION();
12427   }
12428
12429 }
12430
12431
12432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
12433   void * jresult ;
12434   Dali::Shader *arg1 = 0 ;
12435   Dali::Shader *result = 0 ;
12436
12437   arg1 = (Dali::Shader *)jarg1;
12438   if (!arg1) {
12439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
12440     return 0;
12441   }
12442   {
12443     try {
12444       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
12445     } CALL_CATCH_EXCEPTION(0);
12446   }
12447
12448   jresult = (void *)result;
12449   return jresult;
12450 }
12451
12452
12453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
12454   void * jresult ;
12455   Dali::BaseHandle arg1 ;
12456   Dali::BaseHandle *argp1 ;
12457   Dali::Shader result;
12458
12459   argp1 = (Dali::BaseHandle *)jarg1;
12460   if (!argp1) {
12461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12462     return 0;
12463   }
12464   arg1 = *argp1;
12465   {
12466     try {
12467       result = Dali::Shader::DownCast(arg1);
12468     } CALL_CATCH_EXCEPTION(0);
12469   }
12470
12471   jresult = new Dali::Shader((const Dali::Shader &)result);
12472   return jresult;
12473 }
12474
12475
12476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
12477   void * jresult ;
12478   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
12479   Dali::Shader *arg2 = 0 ;
12480   Dali::Shader *result = 0 ;
12481
12482   arg1 = (Dali::Shader *)jarg1;
12483   arg2 = (Dali::Shader *)jarg2;
12484   if (!arg2) {
12485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
12486     return 0;
12487   }
12488   {
12489     try {
12490       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
12491     } CALL_CATCH_EXCEPTION(0);
12492   }
12493
12494   jresult = (void *)result;
12495   return jresult;
12496 }
12497
12498
12499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
12500   int jresult ;
12501   int result;
12502
12503   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
12504   jresult = (int)result;
12505   return jresult;
12506 }
12507
12508
12509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
12510   int jresult ;
12511   int result;
12512
12513   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
12514   jresult = (int)result;
12515   return jresult;
12516 }
12517
12518
12519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
12520   int jresult ;
12521   int result;
12522
12523   result = (int)Dali::Renderer::Property::BLEND_MODE;
12524   jresult = (int)result;
12525   return jresult;
12526 }
12527
12528
12529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
12530   int jresult ;
12531   int result;
12532
12533   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
12534   jresult = (int)result;
12535   return jresult;
12536 }
12537
12538
12539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
12540   int jresult ;
12541   int result;
12542
12543   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
12544   jresult = (int)result;
12545   return jresult;
12546 }
12547
12548
12549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
12550   int jresult ;
12551   int result;
12552
12553   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
12554   jresult = (int)result;
12555   return jresult;
12556 }
12557
12558
12559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
12560   int jresult ;
12561   int result;
12562
12563   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
12564   jresult = (int)result;
12565   return jresult;
12566 }
12567
12568
12569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
12570   int jresult ;
12571   int result;
12572
12573   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
12574   jresult = (int)result;
12575   return jresult;
12576 }
12577
12578
12579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
12580   int jresult ;
12581   int result;
12582
12583   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
12584   jresult = (int)result;
12585   return jresult;
12586 }
12587
12588
12589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
12590   int jresult ;
12591   int result;
12592
12593   result = (int)Dali::Renderer::Property::BLEND_COLOR;
12594   jresult = (int)result;
12595   return jresult;
12596 }
12597
12598
12599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
12600   int jresult ;
12601   int result;
12602
12603   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
12604   jresult = (int)result;
12605   return jresult;
12606 }
12607
12608
12609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
12610   int jresult ;
12611   int result;
12612
12613   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
12614   jresult = (int)result;
12615   return jresult;
12616 }
12617
12618
12619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
12620   int jresult ;
12621   int result;
12622
12623   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
12624   jresult = (int)result;
12625   return jresult;
12626 }
12627
12628
12629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
12630   int jresult ;
12631   int result;
12632
12633   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
12634   jresult = (int)result;
12635   return jresult;
12636 }
12637
12638
12639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
12640   int jresult ;
12641   int result;
12642
12643   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
12644   jresult = (int)result;
12645   return jresult;
12646 }
12647
12648
12649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
12650   int jresult ;
12651   int result;
12652
12653   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
12654   jresult = (int)result;
12655   return jresult;
12656 }
12657
12658
12659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
12660   int jresult ;
12661   int result;
12662
12663   result = (int)Dali::Renderer::Property::RENDER_MODE;
12664   jresult = (int)result;
12665   return jresult;
12666 }
12667
12668
12669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
12670   int jresult ;
12671   int result;
12672
12673   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
12674   jresult = (int)result;
12675   return jresult;
12676 }
12677
12678
12679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
12680   int jresult ;
12681   int result;
12682
12683   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
12684   jresult = (int)result;
12685   return jresult;
12686 }
12687
12688
12689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
12690   int jresult ;
12691   int result;
12692
12693   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
12694   jresult = (int)result;
12695   return jresult;
12696 }
12697
12698
12699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
12700   int jresult ;
12701   int result;
12702
12703   result = (int)Dali::Renderer::Property::STENCIL_MASK;
12704   jresult = (int)result;
12705   return jresult;
12706 }
12707
12708
12709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
12710   int jresult ;
12711   int result;
12712
12713   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
12714   jresult = (int)result;
12715   return jresult;
12716 }
12717
12718
12719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
12720   int jresult ;
12721   int result;
12722
12723   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
12724   jresult = (int)result;
12725   return jresult;
12726 }
12727
12728
12729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
12730   int jresult ;
12731   int result;
12732
12733   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
12734   jresult = (int)result;
12735   return jresult;
12736 }
12737
12738
12739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
12740   void * jresult ;
12741   Dali::Renderer::Property *result = 0 ;
12742
12743   {
12744     try {
12745       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
12746     } CALL_CATCH_EXCEPTION(0);
12747   }
12748
12749   jresult = (void *)result;
12750   return jresult;
12751 }
12752
12753
12754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
12755   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
12756
12757   arg1 = (Dali::Renderer::Property *)jarg1;
12758   {
12759     try {
12760       delete arg1;
12761     } CALL_CATCH_EXCEPTION();
12762   }
12763
12764 }
12765
12766
12767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
12768   void * jresult ;
12769   Dali::Geometry *arg1 = 0 ;
12770   Dali::Shader *arg2 = 0 ;
12771   Dali::Renderer result;
12772
12773   arg1 = (Dali::Geometry *)jarg1;
12774   if (!arg1) {
12775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
12776     return 0;
12777   }
12778   arg2 = (Dali::Shader *)jarg2;
12779   if (!arg2) {
12780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
12781     return 0;
12782   }
12783   {
12784     try {
12785       result = Dali::Renderer::New(*arg1,*arg2);
12786     } CALL_CATCH_EXCEPTION(0);
12787   }
12788
12789   jresult = new Dali::Renderer((const Dali::Renderer &)result);
12790   return jresult;
12791 }
12792
12793
12794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
12795   void * jresult ;
12796   Dali::Renderer *result = 0 ;
12797
12798   {
12799     try {
12800       result = (Dali::Renderer *)new Dali::Renderer();
12801     } CALL_CATCH_EXCEPTION(0);
12802   }
12803
12804   jresult = (void *)result;
12805   return jresult;
12806 }
12807
12808
12809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
12810   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12811
12812   arg1 = (Dali::Renderer *)jarg1;
12813   {
12814     try {
12815       delete arg1;
12816     } CALL_CATCH_EXCEPTION();
12817   }
12818
12819 }
12820
12821
12822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
12823   void * jresult ;
12824   Dali::Renderer *arg1 = 0 ;
12825   Dali::Renderer *result = 0 ;
12826
12827   arg1 = (Dali::Renderer *)jarg1;
12828   if (!arg1) {
12829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
12830     return 0;
12831   }
12832   {
12833     try {
12834       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
12835     } CALL_CATCH_EXCEPTION(0);
12836   }
12837
12838   jresult = (void *)result;
12839   return jresult;
12840 }
12841
12842
12843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
12844   void * jresult ;
12845   Dali::BaseHandle arg1 ;
12846   Dali::BaseHandle *argp1 ;
12847   Dali::Renderer result;
12848
12849   argp1 = (Dali::BaseHandle *)jarg1;
12850   if (!argp1) {
12851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12852     return 0;
12853   }
12854   arg1 = *argp1;
12855   {
12856     try {
12857       result = Dali::Renderer::DownCast(arg1);
12858     } CALL_CATCH_EXCEPTION(0);
12859   }
12860
12861   jresult = new Dali::Renderer((const Dali::Renderer &)result);
12862   return jresult;
12863 }
12864
12865
12866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
12867   void * jresult ;
12868   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12869   Dali::Renderer *arg2 = 0 ;
12870   Dali::Renderer *result = 0 ;
12871
12872   arg1 = (Dali::Renderer *)jarg1;
12873   arg2 = (Dali::Renderer *)jarg2;
12874   if (!arg2) {
12875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
12876     return 0;
12877   }
12878   {
12879     try {
12880       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
12881     } CALL_CATCH_EXCEPTION(0);
12882   }
12883
12884   jresult = (void *)result;
12885   return jresult;
12886 }
12887
12888
12889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
12890   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12891   Dali::Geometry *arg2 = 0 ;
12892
12893   arg1 = (Dali::Renderer *)jarg1;
12894   arg2 = (Dali::Geometry *)jarg2;
12895   if (!arg2) {
12896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
12897     return ;
12898   }
12899   {
12900     try {
12901       (arg1)->SetGeometry(*arg2);
12902     } CALL_CATCH_EXCEPTION();
12903   }
12904
12905 }
12906
12907
12908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
12909   void * jresult ;
12910   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12911   Dali::Geometry result;
12912
12913   arg1 = (Dali::Renderer *)jarg1;
12914   {
12915     try {
12916       result = ((Dali::Renderer const *)arg1)->GetGeometry();
12917     } CALL_CATCH_EXCEPTION(0);
12918   }
12919
12920   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12921   return jresult;
12922 }
12923
12924
12925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
12926   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12927   int arg2 ;
12928   int arg3 ;
12929
12930   arg1 = (Dali::Renderer *)jarg1;
12931   arg2 = (int)jarg2;
12932   arg3 = (int)jarg3;
12933   {
12934     try {
12935       (arg1)->SetIndexRange(arg2,arg3);
12936     } CALL_CATCH_EXCEPTION();
12937   }
12938
12939 }
12940
12941
12942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
12943   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12944   Dali::TextureSet *arg2 = 0 ;
12945
12946   arg1 = (Dali::Renderer *)jarg1;
12947   arg2 = (Dali::TextureSet *)jarg2;
12948   if (!arg2) {
12949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
12950     return ;
12951   }
12952   {
12953     try {
12954       (arg1)->SetTextures(*arg2);
12955     } CALL_CATCH_EXCEPTION();
12956   }
12957
12958 }
12959
12960
12961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
12962   void * jresult ;
12963   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12964   Dali::TextureSet result;
12965
12966   arg1 = (Dali::Renderer *)jarg1;
12967   {
12968     try {
12969       result = ((Dali::Renderer const *)arg1)->GetTextures();
12970     } CALL_CATCH_EXCEPTION(0);
12971   }
12972
12973   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
12974   return jresult;
12975 }
12976
12977
12978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
12979   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12980   Dali::Shader *arg2 = 0 ;
12981
12982   arg1 = (Dali::Renderer *)jarg1;
12983   arg2 = (Dali::Shader *)jarg2;
12984   if (!arg2) {
12985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
12986     return ;
12987   }
12988   {
12989     try {
12990       (arg1)->SetShader(*arg2);
12991     } CALL_CATCH_EXCEPTION();
12992   }
12993
12994 }
12995
12996
12997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
12998   void * jresult ;
12999   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
13000   Dali::Shader result;
13001
13002   arg1 = (Dali::Renderer *)jarg1;
13003   {
13004     try {
13005       result = ((Dali::Renderer const *)arg1)->GetShader();
13006     } CALL_CATCH_EXCEPTION(0);
13007   }
13008
13009   jresult = new Dali::Shader((const Dali::Shader &)result);
13010   return jresult;
13011 }
13012
13013
13014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
13015   void * jresult ;
13016   Dali::FrameBuffer::Attachment *result = 0 ;
13017
13018   {
13019     try {
13020       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
13021     } CALL_CATCH_EXCEPTION(0);
13022   }
13023
13024   jresult = (void *)result;
13025   return jresult;
13026 }
13027
13028
13029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
13030   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
13031
13032   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
13033   {
13034     try {
13035       delete arg1;
13036     } CALL_CATCH_EXCEPTION();
13037   }
13038
13039 }
13040
13041
13042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
13043   void * jresult ;
13044   unsigned int arg1 ;
13045   unsigned int arg2 ;
13046   unsigned int arg3 ;
13047   Dali::FrameBuffer result;
13048
13049   arg1 = (unsigned int)jarg1;
13050   arg2 = (unsigned int)jarg2;
13051   arg3 = (unsigned int)jarg3;
13052   {
13053     try {
13054       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
13055     } CALL_CATCH_EXCEPTION(0);
13056   }
13057
13058   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13059   return jresult;
13060 }
13061
13062
13063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
13064   void * jresult ;
13065   Dali::FrameBuffer *result = 0 ;
13066
13067   {
13068     try {
13069       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
13070     } CALL_CATCH_EXCEPTION(0);
13071   }
13072
13073   jresult = (void *)result;
13074   return jresult;
13075 }
13076
13077
13078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
13079   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13080
13081   arg1 = (Dali::FrameBuffer *)jarg1;
13082   {
13083     try {
13084       delete arg1;
13085     } CALL_CATCH_EXCEPTION();
13086   }
13087
13088 }
13089
13090
13091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
13092   void * jresult ;
13093   Dali::FrameBuffer *arg1 = 0 ;
13094   Dali::FrameBuffer *result = 0 ;
13095
13096   arg1 = (Dali::FrameBuffer *)jarg1;
13097   if (!arg1) {
13098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
13099     return 0;
13100   }
13101   {
13102     try {
13103       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
13104     } CALL_CATCH_EXCEPTION(0);
13105   }
13106
13107   jresult = (void *)result;
13108   return jresult;
13109 }
13110
13111
13112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
13113   void * jresult ;
13114   Dali::BaseHandle arg1 ;
13115   Dali::BaseHandle *argp1 ;
13116   Dali::FrameBuffer result;
13117
13118   argp1 = (Dali::BaseHandle *)jarg1;
13119   if (!argp1) {
13120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13121     return 0;
13122   }
13123   arg1 = *argp1;
13124   {
13125     try {
13126       result = Dali::FrameBuffer::DownCast(arg1);
13127     } CALL_CATCH_EXCEPTION(0);
13128   }
13129
13130   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
13136   void * jresult ;
13137   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13138   Dali::FrameBuffer *arg2 = 0 ;
13139   Dali::FrameBuffer *result = 0 ;
13140
13141   arg1 = (Dali::FrameBuffer *)jarg1;
13142   arg2 = (Dali::FrameBuffer *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
13150     } CALL_CATCH_EXCEPTION(0);
13151   }
13152
13153   jresult = (void *)result;
13154   return jresult;
13155 }
13156
13157
13158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
13159   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13160   Dali::Texture *arg2 = 0 ;
13161
13162   arg1 = (Dali::FrameBuffer *)jarg1;
13163   arg2 = (Dali::Texture *)jarg2;
13164   if (!arg2) {
13165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
13166     return ;
13167   }
13168   {
13169     try {
13170       (arg1)->AttachColorTexture(*arg2);
13171     } CALL_CATCH_EXCEPTION();
13172   }
13173
13174 }
13175
13176
13177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
13178   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13179   Dali::Texture *arg2 = 0 ;
13180   unsigned int arg3 ;
13181   unsigned int arg4 ;
13182
13183   arg1 = (Dali::FrameBuffer *)jarg1;
13184   arg2 = (Dali::Texture *)jarg2;
13185   if (!arg2) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
13187     return ;
13188   }
13189   arg3 = (unsigned int)jarg3;
13190   arg4 = (unsigned int)jarg4;
13191   {
13192     try {
13193       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
13194     } CALL_CATCH_EXCEPTION();
13195   }
13196
13197 }
13198
13199
13200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
13201   void * jresult ;
13202   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
13203   Dali::Texture result;
13204
13205   arg1 = (Dali::FrameBuffer *)jarg1;
13206   {
13207     try {
13208       result = (arg1)->GetColorTexture();
13209     } CALL_CATCH_EXCEPTION(0);
13210   }
13211
13212   jresult = new Dali::Texture((const Dali::Texture &)result);
13213   return jresult;
13214 }
13215
13216 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height)
13217 {
13218   void *jresult;
13219   Dali::Toolkit::ImageUrl result;
13220   Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;;
13221
13222   if (!frameBuffer)
13223   {
13224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0);
13225     return 0;
13226   }
13227   {
13228     try
13229     {
13230       result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height);
13231     }
13232     CALL_CATCH_EXCEPTION(0);
13233   }
13234
13235   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
13236   return jresult;
13237 }
13238
13239
13240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
13241   void * jresult ;
13242   Dali::RenderTaskList *result = 0 ;
13243
13244   {
13245     try {
13246       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
13247     } CALL_CATCH_EXCEPTION(0);
13248   }
13249
13250   jresult = (void *)result;
13251   return jresult;
13252 }
13253
13254
13255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
13256   void * jresult ;
13257   Dali::BaseHandle arg1 ;
13258   Dali::BaseHandle *argp1 ;
13259   Dali::RenderTaskList result;
13260
13261   argp1 = (Dali::BaseHandle *)jarg1;
13262   if (!argp1) {
13263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13264     return 0;
13265   }
13266   arg1 = *argp1;
13267   {
13268     try {
13269       result = Dali::RenderTaskList::DownCast(arg1);
13270     } CALL_CATCH_EXCEPTION(0);
13271   }
13272
13273   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
13274   return jresult;
13275 }
13276
13277
13278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
13279   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13280
13281   arg1 = (Dali::RenderTaskList *)jarg1;
13282   {
13283     try {
13284       delete arg1;
13285     } CALL_CATCH_EXCEPTION();
13286   }
13287
13288 }
13289
13290
13291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
13292   void * jresult ;
13293   Dali::RenderTaskList *arg1 = 0 ;
13294   Dali::RenderTaskList *result = 0 ;
13295
13296   arg1 = (Dali::RenderTaskList *)jarg1;
13297   if (!arg1) {
13298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
13299     return 0;
13300   }
13301   {
13302     try {
13303       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
13304     } CALL_CATCH_EXCEPTION(0);
13305   }
13306
13307   jresult = (void *)result;
13308   return jresult;
13309 }
13310
13311
13312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
13313   void * jresult ;
13314   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13315   Dali::RenderTaskList *arg2 = 0 ;
13316   Dali::RenderTaskList *result = 0 ;
13317
13318   arg1 = (Dali::RenderTaskList *)jarg1;
13319   arg2 = (Dali::RenderTaskList *)jarg2;
13320   if (!arg2) {
13321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
13322     return 0;
13323   }
13324   {
13325     try {
13326       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
13327     } CALL_CATCH_EXCEPTION(0);
13328   }
13329
13330   jresult = (void *)result;
13331   return jresult;
13332 }
13333
13334
13335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
13336   void * jresult ;
13337   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13338   Dali::RenderTask result;
13339
13340   arg1 = (Dali::RenderTaskList *)jarg1;
13341   {
13342     try {
13343       result = (arg1)->CreateTask();
13344     } CALL_CATCH_EXCEPTION(0);
13345   }
13346
13347   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13348   return jresult;
13349 }
13350
13351
13352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
13353   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13354   Dali::RenderTask arg2 ;
13355   Dali::RenderTask *argp2 ;
13356
13357   arg1 = (Dali::RenderTaskList *)jarg1;
13358   argp2 = (Dali::RenderTask *)jarg2;
13359   if (!argp2) {
13360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
13361     return ;
13362   }
13363   arg2 = *argp2;
13364   {
13365     try {
13366       (arg1)->RemoveTask(arg2);
13367     } CALL_CATCH_EXCEPTION();
13368   }
13369
13370 }
13371
13372
13373 //// ===============================================end part 1 =================
13374
13375 //// ========================= part 2 ===============================
13376
13377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
13378   unsigned int jresult ;
13379   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13380   unsigned int result;
13381
13382   arg1 = (Dali::RenderTaskList *)jarg1;
13383   {
13384     try {
13385       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
13386     } CALL_CATCH_EXCEPTION(0);
13387   }
13388
13389   jresult = result;
13390   return jresult;
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
13395   void * jresult ;
13396   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
13397   unsigned int arg2 ;
13398   Dali::RenderTask result;
13399
13400   arg1 = (Dali::RenderTaskList *)jarg1;
13401   arg2 = (unsigned int)jarg2;
13402   {
13403     try {
13404       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
13405     } CALL_CATCH_EXCEPTION(0);
13406   }
13407
13408   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13409   return jresult;
13410 }
13411
13412
13413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
13414   int jresult ;
13415   int result;
13416
13417   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
13418   jresult = (int)result;
13419   return jresult;
13420 }
13421
13422
13423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
13424   int jresult ;
13425   int result;
13426
13427   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
13428   jresult = (int)result;
13429   return jresult;
13430 }
13431
13432
13433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
13434   int jresult ;
13435   int result;
13436
13437   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
13438   jresult = (int)result;
13439   return jresult;
13440 }
13441
13442
13443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
13444   int jresult ;
13445   int result;
13446
13447   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
13448   jresult = (int)result;
13449   return jresult;
13450 }
13451
13452
13453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
13454   void * jresult ;
13455   Dali::RenderTask::Property *result = 0 ;
13456
13457   {
13458     try {
13459       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
13460     } CALL_CATCH_EXCEPTION(0);
13461   }
13462
13463   jresult = (void *)result;
13464   return jresult;
13465 }
13466
13467
13468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
13469   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
13470
13471   arg1 = (Dali::RenderTask::Property *)jarg1;
13472   {
13473     try {
13474       delete arg1;
13475     } CALL_CATCH_EXCEPTION();
13476   }
13477
13478 }
13479
13480
13481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
13482   void * jresult ;
13483   bool (*result)(Dali::Vector2 &) = 0 ;
13484
13485   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
13486   jresult = (void *)result;
13487   return jresult;
13488 }
13489
13490
13491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
13492   void * jresult ;
13493   bool (*result)(Dali::Vector2 &) = 0 ;
13494
13495   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
13496   jresult = (void *)result;
13497   return jresult;
13498 }
13499
13500
13501 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
13502   bool jresult ;
13503   bool result;
13504
13505   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
13506   jresult = result;
13507   return jresult;
13508 }
13509
13510
13511 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
13512   bool jresult ;
13513   bool result;
13514
13515   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
13516   jresult = result;
13517   return jresult;
13518 }
13519
13520
13521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
13522   void * jresult ;
13523   Dali::Vector4 *result = 0 ;
13524
13525   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
13526   jresult = (void *)result;
13527   return jresult;
13528 }
13529
13530
13531 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
13532   bool jresult ;
13533   bool result;
13534
13535   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
13536   jresult = result;
13537   return jresult;
13538 }
13539
13540
13541 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
13542   bool jresult ;
13543   bool result;
13544
13545   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
13546   jresult = result;
13547   return jresult;
13548 }
13549
13550
13551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
13552   unsigned int jresult ;
13553   unsigned int result;
13554
13555   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
13556   jresult = result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
13562   void * jresult ;
13563   Dali::RenderTask *result = 0 ;
13564
13565   {
13566     try {
13567       result = (Dali::RenderTask *)new Dali::RenderTask();
13568     } CALL_CATCH_EXCEPTION(0);
13569   }
13570
13571   jresult = (void *)result;
13572   return jresult;
13573 }
13574
13575
13576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
13577   void * jresult ;
13578   Dali::BaseHandle arg1 ;
13579   Dali::BaseHandle *argp1 ;
13580   Dali::RenderTask result;
13581
13582   argp1 = (Dali::BaseHandle *)jarg1;
13583   if (!argp1) {
13584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13585     return 0;
13586   }
13587   arg1 = *argp1;
13588   {
13589     try {
13590       result = Dali::RenderTask::DownCast(arg1);
13591     } CALL_CATCH_EXCEPTION(0);
13592   }
13593
13594   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13595   return jresult;
13596 }
13597
13598
13599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
13600   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13601
13602   arg1 = (Dali::RenderTask *)jarg1;
13603   {
13604     try {
13605       delete arg1;
13606     } CALL_CATCH_EXCEPTION();
13607   }
13608
13609 }
13610
13611
13612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
13613   void * jresult ;
13614   Dali::RenderTask *arg1 = 0 ;
13615   Dali::RenderTask *result = 0 ;
13616
13617   arg1 = (Dali::RenderTask *)jarg1;
13618   if (!arg1) {
13619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
13620     return 0;
13621   }
13622   {
13623     try {
13624       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
13625     } CALL_CATCH_EXCEPTION(0);
13626   }
13627
13628   jresult = (void *)result;
13629   return jresult;
13630 }
13631
13632
13633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
13634   void * jresult ;
13635   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13636   Dali::RenderTask *arg2 = 0 ;
13637   Dali::RenderTask *result = 0 ;
13638
13639   arg1 = (Dali::RenderTask *)jarg1;
13640   arg2 = (Dali::RenderTask *)jarg2;
13641   if (!arg2) {
13642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
13643     return 0;
13644   }
13645   {
13646     try {
13647       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
13648     } CALL_CATCH_EXCEPTION(0);
13649   }
13650
13651   jresult = (void *)result;
13652   return jresult;
13653 }
13654
13655
13656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
13657   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13658   Dali::Actor arg2 ;
13659   Dali::Actor *argp2 ;
13660
13661   arg1 = (Dali::RenderTask *)jarg1;
13662   argp2 = (Dali::Actor *)jarg2;
13663   if (!argp2) {
13664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13665     return ;
13666   }
13667   arg2 = *argp2;
13668   {
13669     try {
13670       (arg1)->SetSourceActor(arg2);
13671     } CALL_CATCH_EXCEPTION();
13672   }
13673
13674 }
13675
13676
13677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
13678   void * jresult ;
13679   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13680   Dali::Actor result;
13681
13682   arg1 = (Dali::RenderTask *)jarg1;
13683   {
13684     try {
13685       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
13686     } CALL_CATCH_EXCEPTION(0);
13687   }
13688
13689   jresult = new Dali::Actor((const Dali::Actor &)result);
13690   return jresult;
13691 }
13692
13693
13694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
13695   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13696   bool arg2 ;
13697
13698   arg1 = (Dali::RenderTask *)jarg1;
13699   arg2 = jarg2 ? true : false;
13700   {
13701     try {
13702       (arg1)->SetExclusive(arg2);
13703     } CALL_CATCH_EXCEPTION();
13704   }
13705
13706 }
13707
13708
13709 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
13710   bool jresult ;
13711   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13712   bool result;
13713
13714   arg1 = (Dali::RenderTask *)jarg1;
13715   {
13716     try {
13717       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
13718     } CALL_CATCH_EXCEPTION(0);
13719   }
13720
13721   jresult = result;
13722   return jresult;
13723 }
13724
13725
13726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
13727   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13728   bool arg2 ;
13729
13730   arg1 = (Dali::RenderTask *)jarg1;
13731   arg2 = jarg2 ? true : false;
13732   {
13733     try {
13734       (arg1)->SetInputEnabled(arg2);
13735     } CALL_CATCH_EXCEPTION();
13736   }
13737
13738 }
13739
13740
13741 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
13742   bool jresult ;
13743   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13744   bool result;
13745
13746   arg1 = (Dali::RenderTask *)jarg1;
13747   {
13748     try {
13749       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
13750     } CALL_CATCH_EXCEPTION(0);
13751   }
13752
13753   jresult = result;
13754   return jresult;
13755 }
13756
13757
13758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
13759   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13760   Dali::CameraActor arg2 ;
13761   Dali::CameraActor *argp2 ;
13762
13763   arg1 = (Dali::RenderTask *)jarg1;
13764   argp2 = (Dali::CameraActor *)jarg2;
13765   if (!argp2) {
13766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
13767     return ;
13768   }
13769   arg2 = *argp2;
13770   {
13771     try {
13772       (arg1)->SetCameraActor(arg2);
13773     } CALL_CATCH_EXCEPTION();
13774   }
13775
13776 }
13777
13778
13779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
13780   void * jresult ;
13781   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13782   Dali::CameraActor result;
13783
13784   arg1 = (Dali::RenderTask *)jarg1;
13785   {
13786     try {
13787       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
13788     } CALL_CATCH_EXCEPTION(0);
13789   }
13790
13791   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
13792   return jresult;
13793 }
13794
13795
13796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
13797   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13798   Dali::FrameBuffer arg2 ;
13799   Dali::FrameBuffer *argp2 ;
13800
13801   arg1 = (Dali::RenderTask *)jarg1;
13802   argp2 = (Dali::FrameBuffer *)jarg2;
13803   if (!argp2) {
13804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
13805     return ;
13806   }
13807   arg2 = *argp2;
13808   {
13809     try {
13810       (arg1)->SetFrameBuffer(arg2);
13811     } CALL_CATCH_EXCEPTION();
13812   }
13813
13814 }
13815
13816
13817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
13818   void * jresult ;
13819   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13820   Dali::FrameBuffer result;
13821
13822   arg1 = (Dali::RenderTask *)jarg1;
13823   {
13824     try {
13825       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
13826     } CALL_CATCH_EXCEPTION(0);
13827   }
13828
13829   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13830   return jresult;
13831 }
13832
13833
13834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
13835   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13836   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
13837
13838   arg1 = (Dali::RenderTask *)jarg1;
13839   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
13840   {
13841     try {
13842       (arg1)->SetScreenToFrameBufferFunction(arg2);
13843     } CALL_CATCH_EXCEPTION();
13844   }
13845
13846 }
13847
13848
13849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
13850   void * jresult ;
13851   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13852   Dali::RenderTask::ScreenToFrameBufferFunction result;
13853
13854   arg1 = (Dali::RenderTask *)jarg1;
13855   {
13856     try {
13857       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
13858     } CALL_CATCH_EXCEPTION(0);
13859   }
13860
13861   jresult = (void *)result;
13862   return jresult;
13863 }
13864
13865
13866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
13867   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13868   Dali::Actor arg2 ;
13869   Dali::Actor *argp2 ;
13870
13871   arg1 = (Dali::RenderTask *)jarg1;
13872   argp2 = (Dali::Actor *)jarg2;
13873   if (!argp2) {
13874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13875     return ;
13876   }
13877   arg2 = *argp2;
13878   {
13879     try {
13880       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
13881     } CALL_CATCH_EXCEPTION();
13882   }
13883
13884 }
13885
13886
13887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
13888   void * jresult ;
13889   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13890   Dali::Actor result;
13891
13892   arg1 = (Dali::RenderTask *)jarg1;
13893   {
13894     try {
13895       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
13896     } CALL_CATCH_EXCEPTION(0);
13897   }
13898
13899   jresult = new Dali::Actor((const Dali::Actor &)result);
13900   return jresult;
13901 }
13902
13903
13904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
13905   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13906   Dali::Vector2 arg2 ;
13907   Dali::Vector2 *argp2 ;
13908
13909   arg1 = (Dali::RenderTask *)jarg1;
13910   argp2 = (Dali::Vector2 *)jarg2;
13911   if (!argp2) {
13912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
13913     return ;
13914   }
13915   arg2 = *argp2;
13916   {
13917     try {
13918       (arg1)->SetViewportPosition(arg2);
13919     } CALL_CATCH_EXCEPTION();
13920   }
13921
13922 }
13923
13924
13925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
13926   void * jresult ;
13927   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13928   Dali::Vector2 result;
13929
13930   arg1 = (Dali::RenderTask *)jarg1;
13931   {
13932     try {
13933       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
13934     } CALL_CATCH_EXCEPTION(0);
13935   }
13936
13937   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
13938   return jresult;
13939 }
13940
13941
13942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
13943   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13944   Dali::Vector2 arg2 ;
13945   Dali::Vector2 *argp2 ;
13946
13947   arg1 = (Dali::RenderTask *)jarg1;
13948   argp2 = (Dali::Vector2 *)jarg2;
13949   if (!argp2) {
13950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
13951     return ;
13952   }
13953   arg2 = *argp2;
13954   {
13955     try {
13956       (arg1)->SetViewportSize(arg2);
13957     } CALL_CATCH_EXCEPTION();
13958   }
13959
13960 }
13961
13962
13963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
13964   void * jresult ;
13965   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13966   Dali::Vector2 result;
13967
13968   arg1 = (Dali::RenderTask *)jarg1;
13969   {
13970     try {
13971       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
13972     } CALL_CATCH_EXCEPTION(0);
13973   }
13974
13975   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
13976   return jresult;
13977 }
13978
13979
13980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
13981   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13982   Dali::Viewport arg2 ;
13983   Dali::Viewport *argp2 ;
13984
13985   arg1 = (Dali::RenderTask *)jarg1;
13986   argp2 = (Dali::Viewport *)jarg2;
13987   if (!argp2) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
13989     return ;
13990   }
13991   arg2 = *argp2;
13992   {
13993     try {
13994       (arg1)->SetViewport(arg2);
13995     } CALL_CATCH_EXCEPTION();
13996   }
13997
13998 }
13999
14000
14001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
14002   void * jresult ;
14003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14004   Dali::Viewport result;
14005
14006   arg1 = (Dali::RenderTask *)jarg1;
14007   {
14008     try {
14009       result = ((Dali::RenderTask const *)arg1)->GetViewport();
14010     } CALL_CATCH_EXCEPTION(0);
14011   }
14012
14013   jresult = new Dali::Viewport((const Dali::Viewport &)result);
14014   return jresult;
14015 }
14016
14017
14018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
14019   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14020   Dali::Vector4 *arg2 = 0 ;
14021
14022   arg1 = (Dali::RenderTask *)jarg1;
14023   arg2 = (Dali::Vector4 *)jarg2;
14024   if (!arg2) {
14025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14026     return ;
14027   }
14028   {
14029     try {
14030       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
14031     } CALL_CATCH_EXCEPTION();
14032   }
14033
14034 }
14035
14036
14037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
14038   void * jresult ;
14039   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14040   Dali::Vector4 result;
14041
14042   arg1 = (Dali::RenderTask *)jarg1;
14043   {
14044     try {
14045       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
14046     } CALL_CATCH_EXCEPTION(0);
14047   }
14048
14049   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14050   return jresult;
14051 }
14052
14053
14054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
14055   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14056   bool arg2 ;
14057
14058   arg1 = (Dali::RenderTask *)jarg1;
14059   arg2 = jarg2 ? true : false;
14060   {
14061     try {
14062       (arg1)->SetClearEnabled(arg2);
14063     } CALL_CATCH_EXCEPTION();
14064   }
14065
14066 }
14067
14068
14069 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
14070   bool jresult ;
14071   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14072   bool result;
14073
14074   arg1 = (Dali::RenderTask *)jarg1;
14075   {
14076     try {
14077       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
14078     } CALL_CATCH_EXCEPTION(0);
14079   }
14080
14081   jresult = result;
14082   return jresult;
14083 }
14084
14085
14086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
14087   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14088   bool arg2 ;
14089
14090   arg1 = (Dali::RenderTask *)jarg1;
14091   arg2 = jarg2 ? true : false;
14092   {
14093     try {
14094       (arg1)->SetCullMode(arg2);
14095     } CALL_CATCH_EXCEPTION();
14096   }
14097
14098 }
14099
14100
14101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
14102   bool jresult ;
14103   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14104   bool result;
14105
14106   arg1 = (Dali::RenderTask *)jarg1;
14107   {
14108     try {
14109       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
14110     } CALL_CATCH_EXCEPTION(0);
14111   }
14112
14113   jresult = result;
14114   return jresult;
14115 }
14116
14117
14118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
14119   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14120   unsigned int arg2 ;
14121
14122   arg1 = (Dali::RenderTask *)jarg1;
14123   arg2 = (unsigned int)jarg2;
14124   {
14125     try {
14126       (arg1)->SetRefreshRate(arg2);
14127     } CALL_CATCH_EXCEPTION();
14128   }
14129
14130 }
14131
14132
14133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
14134   unsigned int jresult ;
14135   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14136   unsigned int result;
14137
14138   arg1 = (Dali::RenderTask *)jarg1;
14139   {
14140     try {
14141       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
14142     } CALL_CATCH_EXCEPTION(0);
14143   }
14144
14145   jresult = result;
14146   return jresult;
14147 }
14148
14149
14150 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
14151   bool jresult ;
14152   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14153   Dali::Vector3 *arg2 = 0 ;
14154   float *arg3 = 0 ;
14155   float *arg4 = 0 ;
14156   bool result;
14157
14158   arg1 = (Dali::RenderTask *)jarg1;
14159   arg2 = (Dali::Vector3 *)jarg2;
14160   if (!arg2) {
14161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14162     return 0;
14163   }
14164   arg3 = (float *)jarg3;
14165   arg4 = (float *)jarg4;
14166   {
14167     try {
14168       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
14169     } CALL_CATCH_EXCEPTION(0);
14170   }
14171
14172   jresult = result;
14173   return jresult;
14174 }
14175
14176
14177 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
14178   bool jresult ;
14179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14180   Dali::Actor arg2 ;
14181   float arg3 ;
14182   float arg4 ;
14183   float *arg5 = 0 ;
14184   float *arg6 = 0 ;
14185   Dali::Actor *argp2 ;
14186   bool result;
14187
14188   arg1 = (Dali::RenderTask *)jarg1;
14189   argp2 = (Dali::Actor *)jarg2;
14190   if (!argp2) {
14191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14192     return 0;
14193   }
14194   arg2 = *argp2;
14195   arg3 = (float)jarg3;
14196   arg4 = (float)jarg4;
14197   arg5 = (float *)jarg5;
14198   arg6 = (float *)jarg6;
14199   {
14200     try {
14201       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
14202     } CALL_CATCH_EXCEPTION(0);
14203   }
14204
14205   jresult = result;
14206   return jresult;
14207 }
14208
14209
14210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
14211   void * jresult ;
14212   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
14213   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
14214
14215   arg1 = (Dali::RenderTask *)jarg1;
14216   {
14217     try {
14218       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
14219     } CALL_CATCH_EXCEPTION(0);
14220   }
14221
14222   jresult = (void *)result;
14223   return jresult;
14224 }
14225
14226
14227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
14228   void * jresult ;
14229   int arg1 ;
14230   Dali::PointState::Type arg2 ;
14231   float arg3 ;
14232   float arg4 ;
14233   Dali::TouchPoint *result = 0 ;
14234
14235   arg1 = (int)jarg1;
14236   arg2 = (Dali::PointState::Type)jarg2;
14237   arg3 = (float)jarg3;
14238   arg4 = (float)jarg4;
14239   {
14240     try {
14241       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
14242     } CALL_CATCH_EXCEPTION(0);
14243   }
14244
14245   jresult = (void *)result;
14246   return jresult;
14247 }
14248
14249
14250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
14251   void * jresult ;
14252   int arg1 ;
14253   Dali::PointState::Type arg2 ;
14254   float arg3 ;
14255   float arg4 ;
14256   float arg5 ;
14257   float arg6 ;
14258   Dali::TouchPoint *result = 0 ;
14259
14260   arg1 = (int)jarg1;
14261   arg2 = (Dali::PointState::Type)jarg2;
14262   arg3 = (float)jarg3;
14263   arg4 = (float)jarg4;
14264   arg5 = (float)jarg5;
14265   arg6 = (float)jarg6;
14266   {
14267     try {
14268       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
14269     } CALL_CATCH_EXCEPTION(0);
14270   }
14271
14272   jresult = (void *)result;
14273   return jresult;
14274 }
14275
14276
14277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
14278   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14279
14280   arg1 = (Dali::TouchPoint *)jarg1;
14281   {
14282     try {
14283       delete arg1;
14284     } CALL_CATCH_EXCEPTION();
14285   }
14286
14287 }
14288
14289
14290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
14291   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14292   int arg2 ;
14293
14294   arg1 = (Dali::TouchPoint *)jarg1;
14295   arg2 = (int)jarg2;
14296   if (arg1) (arg1)->deviceId = arg2;
14297 }
14298
14299
14300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
14301   int jresult ;
14302   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14303   int result;
14304
14305   arg1 = (Dali::TouchPoint *)jarg1;
14306   result = (int) ((arg1)->deviceId);
14307   jresult = result;
14308   return jresult;
14309 }
14310
14311
14312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
14313   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14314   Dali::PointState::Type arg2 ;
14315
14316   arg1 = (Dali::TouchPoint *)jarg1;
14317   arg2 = (Dali::PointState::Type)jarg2;
14318   if (arg1) (arg1)->state = arg2;
14319 }
14320
14321
14322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
14323   int jresult ;
14324   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14325   Dali::PointState::Type result;
14326
14327   arg1 = (Dali::TouchPoint *)jarg1;
14328   result = (Dali::PointState::Type) ((arg1)->state);
14329   jresult = (int)result;
14330   return jresult;
14331 }
14332
14333
14334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
14335   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14336   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
14337
14338   arg1 = (Dali::TouchPoint *)jarg1;
14339   arg2 = (Dali::Actor *)jarg2;
14340   if (arg1) (arg1)->hitActor = *arg2;
14341 }
14342
14343
14344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
14345   void * jresult ;
14346   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14347   Dali::Actor *result = 0 ;
14348
14349   arg1 = (Dali::TouchPoint *)jarg1;
14350   result = (Dali::Actor *)& ((arg1)->hitActor);
14351   jresult = (void *)result;
14352   return jresult;
14353 }
14354
14355
14356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
14357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14358   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
14359
14360   arg1 = (Dali::TouchPoint *)jarg1;
14361   arg2 = (Dali::Vector2 *)jarg2;
14362   if (arg1) (arg1)->local = *arg2;
14363 }
14364
14365
14366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
14367   void * jresult ;
14368   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14369   Dali::Vector2 *result = 0 ;
14370
14371   arg1 = (Dali::TouchPoint *)jarg1;
14372   result = (Dali::Vector2 *)& ((arg1)->local);
14373   jresult = (void *)result;
14374   return jresult;
14375 }
14376
14377
14378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
14379   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14380   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
14381
14382   arg1 = (Dali::TouchPoint *)jarg1;
14383   arg2 = (Dali::Vector2 *)jarg2;
14384   if (arg1) (arg1)->screen = *arg2;
14385 }
14386
14387
14388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
14389   void * jresult ;
14390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
14391   Dali::Vector2 *result = 0 ;
14392
14393   arg1 = (Dali::TouchPoint *)jarg1;
14394   result = (Dali::Vector2 *)& ((arg1)->screen);
14395   jresult = (void *)result;
14396   return jresult;
14397 }
14398
14399
14400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
14401   void * jresult ;
14402   Dali::TouchEvent *result = 0 ;
14403
14404   {
14405     try {
14406       result = (Dali::TouchEvent *)new Dali::TouchEvent();
14407     } CALL_CATCH_EXCEPTION(0);
14408   }
14409
14410   jresult = (void *)result;
14411   return jresult;
14412 }
14413
14414
14415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
14416   void * jresult ;
14417   Dali::TouchEvent *arg1 = 0 ;
14418   Dali::TouchEvent *result = 0 ;
14419
14420   arg1 = (Dali::TouchEvent *)jarg1;
14421   if (!arg1) {
14422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
14423     return 0;
14424   }
14425   {
14426     try {
14427       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
14428     } CALL_CATCH_EXCEPTION(0);
14429   }
14430
14431   jresult = (void *)result;
14432   return jresult;
14433 }
14434
14435
14436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
14437   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14438
14439   arg1 = (Dali::TouchEvent *)jarg1;
14440   {
14441     try {
14442       delete arg1;
14443     } CALL_CATCH_EXCEPTION();
14444   }
14445
14446 }
14447
14448
14449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
14450   void * jresult ;
14451   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14452   Dali::TouchEvent *arg2 = 0 ;
14453   Dali::TouchEvent *result = 0 ;
14454
14455   arg1 = (Dali::TouchEvent *)jarg1;
14456   arg2 = (Dali::TouchEvent *)jarg2;
14457   if (!arg2) {
14458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
14459     return 0;
14460   }
14461   {
14462     try {
14463       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
14464     } CALL_CATCH_EXCEPTION(0);
14465   }
14466
14467   jresult = (void *)result;
14468   return jresult;
14469 }
14470
14471
14472 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
14473   unsigned long jresult ;
14474   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14475   unsigned long result;
14476
14477   arg1 = (Dali::TouchEvent *)jarg1;
14478   {
14479     try {
14480       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
14481     } CALL_CATCH_EXCEPTION(0);
14482   }
14483
14484   jresult = (unsigned long)result;
14485   return jresult;
14486 }
14487
14488
14489 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
14490   unsigned long jresult ;
14491   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14492   std::size_t result;
14493
14494   arg1 = (Dali::TouchEvent *)jarg1;
14495   {
14496     try {
14497       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
14498     } CALL_CATCH_EXCEPTION(0);
14499   }
14500
14501   jresult = (unsigned long)result;
14502   return jresult;
14503 }
14504
14505
14506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
14507   int jresult ;
14508   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14509   std::size_t arg2 ;
14510   int32_t result;
14511
14512   arg1 = (Dali::TouchEvent *)jarg1;
14513   arg2 = (std::size_t)jarg2;
14514   {
14515     try {
14516       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
14517     } CALL_CATCH_EXCEPTION(0);
14518   }
14519
14520   jresult = result;
14521   return jresult;
14522 }
14523
14524
14525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
14526   int jresult ;
14527   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14528   std::size_t arg2 ;
14529   Dali::PointState::Type result;
14530
14531   arg1 = (Dali::TouchEvent *)jarg1;
14532   arg2 = (std::size_t)jarg2;
14533   {
14534     try {
14535       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
14536     } CALL_CATCH_EXCEPTION(0);
14537   }
14538
14539   jresult = (int)result;
14540   return jresult;
14541 }
14542
14543
14544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
14545   void * jresult ;
14546   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14547   std::size_t arg2 ;
14548   Dali::Actor result;
14549
14550   arg1 = (Dali::TouchEvent *)jarg1;
14551   arg2 = (std::size_t)jarg2;
14552   {
14553     try {
14554       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
14555     } CALL_CATCH_EXCEPTION(0);
14556   }
14557
14558   jresult = new Dali::Actor((const Dali::Actor &)result);
14559   return jresult;
14560 }
14561
14562
14563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
14564   void * jresult ;
14565   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14566   std::size_t arg2 ;
14567   Dali::Vector2 *result = 0 ;
14568
14569   arg1 = (Dali::TouchEvent *)jarg1;
14570   arg2 = (std::size_t)jarg2;
14571   {
14572     try {
14573       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
14574     } CALL_CATCH_EXCEPTION(0);
14575   }
14576
14577   jresult = (void *)result;
14578   return jresult;
14579 }
14580
14581
14582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
14583   void * jresult ;
14584   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14585   std::size_t arg2 ;
14586   Dali::Vector2 *result = 0 ;
14587
14588   arg1 = (Dali::TouchEvent *)jarg1;
14589   arg2 = (std::size_t)jarg2;
14590   {
14591     try {
14592       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
14593     } CALL_CATCH_EXCEPTION(0);
14594   }
14595
14596   jresult = (void *)result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
14602   float jresult ;
14603   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14604   std::size_t arg2 ;
14605   float result;
14606
14607   arg1 = (Dali::TouchEvent *)jarg1;
14608   arg2 = (std::size_t)jarg2;
14609   {
14610     try {
14611       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
14612     } CALL_CATCH_EXCEPTION(0);
14613   }
14614
14615   jresult = result;
14616   return jresult;
14617 }
14618
14619
14620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
14621   void * jresult ;
14622   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14623   std::size_t arg2 ;
14624   Dali::Vector2 *result = 0 ;
14625
14626   arg1 = (Dali::TouchEvent *)jarg1;
14627   arg2 = (std::size_t)jarg2;
14628   {
14629     try {
14630       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
14631     } CALL_CATCH_EXCEPTION(0);
14632   }
14633
14634   jresult = (void *)result;
14635   return jresult;
14636 }
14637
14638
14639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
14640   float jresult ;
14641   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14642   std::size_t arg2 ;
14643   float result;
14644
14645   arg1 = (Dali::TouchEvent *)jarg1;
14646   arg2 = (std::size_t)jarg2;
14647   {
14648     try {
14649       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
14650     } CALL_CATCH_EXCEPTION(0);
14651   }
14652
14653   jresult = result;
14654   return jresult;
14655 }
14656
14657
14658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
14659   void * jresult ;
14660   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14661   std::size_t arg2 ;
14662   Dali::Degree result;
14663
14664   arg1 = (Dali::TouchEvent *)jarg1;
14665   arg2 = (std::size_t)jarg2;
14666   {
14667     try {
14668       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
14669     } CALL_CATCH_EXCEPTION(0);
14670   }
14671
14672   jresult = new Dali::Degree((const Dali::Degree &)result);
14673   return jresult;
14674 }
14675
14676
14677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) {
14678   int jresult ;
14679   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14680   std::size_t arg2 ;
14681   Dali::Device::Class::Type result;
14682
14683   arg1 = (Dali::TouchEvent *)jarg1;
14684   arg2 = (std::size_t)jarg2;
14685   {
14686     try {
14687       result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2);
14688     } CALL_CATCH_EXCEPTION(0);
14689   }
14690
14691   jresult = (int)result;
14692   return jresult;
14693 }
14694
14695
14696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) {
14697   int jresult ;
14698   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14699   std::size_t arg2 ;
14700   Dali::Device::Subclass::Type result;
14701
14702   arg1 = (Dali::TouchEvent *)jarg1;
14703   arg2 = (std::size_t)jarg2;
14704   {
14705     try {
14706       result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2);
14707     } CALL_CATCH_EXCEPTION(0);
14708   }
14709
14710   jresult = (int)result;
14711   return jresult;
14712 }
14713
14714
14715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
14716   int jresult ;
14717   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14718   std::size_t arg2 ;
14719   Dali::MouseButton::Type result;
14720
14721   arg1 = (Dali::TouchEvent *)jarg1;
14722   arg2 = (std::size_t)jarg2;
14723   {
14724     try {
14725       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
14726     } CALL_CATCH_EXCEPTION(0);
14727   }
14728
14729   jresult = static_cast< int >(result);
14730   return jresult;
14731 }
14732
14733
14734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
14735   void * jresult ;
14736   Dali::GestureDetector *result = 0 ;
14737
14738   {
14739     try {
14740       result = (Dali::GestureDetector *)new Dali::GestureDetector();
14741     } CALL_CATCH_EXCEPTION(0);
14742   }
14743
14744   jresult = (void *)result;
14745   return jresult;
14746 }
14747
14748
14749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
14750   void * jresult ;
14751   Dali::BaseHandle arg1 ;
14752   Dali::BaseHandle *argp1 ;
14753   Dali::GestureDetector result;
14754
14755   argp1 = (Dali::BaseHandle *)jarg1;
14756   if (!argp1) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
14758     return 0;
14759   }
14760   arg1 = *argp1;
14761   {
14762     try {
14763       result = Dali::GestureDetector::DownCast(arg1);
14764     } CALL_CATCH_EXCEPTION(0);
14765   }
14766
14767   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
14768   return jresult;
14769 }
14770
14771
14772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
14773   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14774
14775   arg1 = (Dali::GestureDetector *)jarg1;
14776   {
14777     try {
14778       delete arg1;
14779     } CALL_CATCH_EXCEPTION();
14780   }
14781
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
14786   void * jresult ;
14787   Dali::GestureDetector *arg1 = 0 ;
14788   Dali::GestureDetector *result = 0 ;
14789
14790   arg1 = (Dali::GestureDetector *)jarg1;
14791   if (!arg1) {
14792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
14793     return 0;
14794   }
14795   {
14796     try {
14797       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
14798     } CALL_CATCH_EXCEPTION(0);
14799   }
14800
14801   jresult = (void *)result;
14802   return jresult;
14803 }
14804
14805
14806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
14807   void * jresult ;
14808   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14809   Dali::GestureDetector *arg2 = 0 ;
14810   Dali::GestureDetector *result = 0 ;
14811
14812   arg1 = (Dali::GestureDetector *)jarg1;
14813   arg2 = (Dali::GestureDetector *)jarg2;
14814   if (!arg2) {
14815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
14816     return 0;
14817   }
14818   {
14819     try {
14820       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
14821     } CALL_CATCH_EXCEPTION(0);
14822   }
14823
14824   jresult = (void *)result;
14825   return jresult;
14826 }
14827
14828
14829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
14830   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14831   Dali::Actor arg2 ;
14832   Dali::Actor *argp2 ;
14833
14834   arg1 = (Dali::GestureDetector *)jarg1;
14835   argp2 = (Dali::Actor *)jarg2;
14836   if (!argp2) {
14837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14838     return ;
14839   }
14840   arg2 = *argp2;
14841   {
14842     try {
14843       (arg1)->Attach(arg2);
14844     } CALL_CATCH_EXCEPTION();
14845   }
14846
14847 }
14848
14849
14850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
14851   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14852   Dali::Actor arg2 ;
14853   Dali::Actor *argp2 ;
14854
14855   arg1 = (Dali::GestureDetector *)jarg1;
14856   argp2 = (Dali::Actor *)jarg2;
14857   if (!argp2) {
14858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14859     return ;
14860   }
14861   arg2 = *argp2;
14862   {
14863     try {
14864       (arg1)->Detach(arg2);
14865     } CALL_CATCH_EXCEPTION();
14866   }
14867
14868 }
14869
14870
14871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
14872   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14873
14874   arg1 = (Dali::GestureDetector *)jarg1;
14875   {
14876     try {
14877       (arg1)->DetachAll();
14878     } CALL_CATCH_EXCEPTION();
14879   }
14880
14881 }
14882
14883
14884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
14885   unsigned long jresult ;
14886   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14887   size_t result;
14888
14889   arg1 = (Dali::GestureDetector *)jarg1;
14890   {
14891     try {
14892       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
14893     } CALL_CATCH_EXCEPTION(0);
14894   }
14895
14896   jresult = (unsigned long)result;
14897   return jresult;
14898 }
14899
14900
14901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
14902   void * jresult ;
14903   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14904   size_t arg2 ;
14905   Dali::Actor result;
14906
14907   arg1 = (Dali::GestureDetector *)jarg1;
14908   arg2 = (size_t)jarg2;
14909   {
14910     try {
14911       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
14912     } CALL_CATCH_EXCEPTION(0);
14913   }
14914
14915   jresult = new Dali::Actor((const Dali::Actor &)result);
14916   return jresult;
14917 }
14918
14919 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GestureDetector_FeedTouch(void * jdetector, void * jactor, void * jtouch) {
14920   bool result = false;
14921   Dali::GestureDetector *detector = (Dali::GestureDetector *)jdetector;
14922   Dali::Actor *actor = (Dali::Actor *)jactor;
14923   Dali::TouchEvent *touchEvent = (Dali::TouchEvent *)jtouch;
14924
14925   {
14926     try {
14927       result = ((Dali::GestureDetector *)detector)->FeedTouch(*actor, *touchEvent);
14928     } CALL_CATCH_EXCEPTION(0);
14929   }
14930
14931   return result;
14932 }
14933
14934
14935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
14936   void * jresult ;
14937   Dali::Gesture *arg1 = 0 ;
14938   Dali::Gesture *result = 0 ;
14939
14940   arg1 = (Dali::Gesture *)jarg1;
14941   if (!arg1) {
14942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14943     return 0;
14944   }
14945   {
14946     try {
14947       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
14948     } CALL_CATCH_EXCEPTION(0);
14949   }
14950
14951   jresult = (void *)result;
14952   return jresult;
14953 }
14954
14955
14956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
14957   void * jresult ;
14958   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14959   Dali::Gesture *arg2 = 0 ;
14960   Dali::Gesture *result = 0 ;
14961
14962   arg1 = (Dali::Gesture *)jarg1;
14963   arg2 = (Dali::Gesture *)jarg2;
14964   if (!arg2) {
14965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14966     return 0;
14967   }
14968   {
14969     try {
14970       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
14971     } CALL_CATCH_EXCEPTION(0);
14972   }
14973
14974   jresult = (void *)result;
14975   return jresult;
14976 }
14977
14978
14979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
14980   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14981
14982   arg1 = (Dali::Gesture *)jarg1;
14983   {
14984     try {
14985       delete arg1;
14986     } CALL_CATCH_EXCEPTION();
14987   }
14988
14989 }
14990
14991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
14992   int jresult ;
14993   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14994   Dali::GestureType::Value result;
14995
14996   arg1 = (Dali::Gesture *)jarg1;
14997   result = (Dali::GestureType::Value) ((arg1)->GetType());
14998   jresult = (int)result;
14999   return jresult;
15000 }
15001
15002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
15003   int jresult ;
15004   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
15005   Dali::GestureState result;
15006
15007   arg1 = (Dali::Gesture *)jarg1;
15008   result = (Dali::GestureState) ((arg1)->GetState());
15009   jresult = (int)result;
15010   return jresult;
15011 }
15012
15013 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
15014   unsigned int jresult ;
15015   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
15016   unsigned int result;
15017
15018   arg1 = (Dali::Gesture *)jarg1;
15019   result = (unsigned int) ((arg1)->GetTime());
15020   jresult = result;
15021   return jresult;
15022 }
15023
15024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
15025   int jresult ;
15026   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
15027   Dali::GestureSourceType result;
15028
15029   if (!jGesture) {
15030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
15031     return 0;
15032   }
15033   {
15034     try {
15035       result = (Dali::GestureSourceType)jGesture->GetSourceType();
15036     } CALL_CATCH_EXCEPTION(0);
15037   }
15038
15039   jresult = (int)result;
15040   return jresult;
15041 }
15042
15043
15044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
15045   int jresult ;
15046   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
15047   Dali::GestureSourceData result;
15048
15049   if (!jGesture) {
15050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
15051     return 0;
15052   }
15053   {
15054     try {
15055       result = (Dali::GestureSourceData)jGesture->GetSourceData();
15056     } CALL_CATCH_EXCEPTION(0);
15057   }
15058
15059   jresult = (int)result;
15060   return jresult;
15061 }
15062
15063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
15064   void * jresult ;
15065   Dali::HoverEvent *result = 0 ;
15066
15067   {
15068     try {
15069       result = (Dali::HoverEvent *)new Dali::HoverEvent();
15070     } CALL_CATCH_EXCEPTION(0);
15071   }
15072
15073   jresult = (void *)result;
15074   return jresult;
15075 }
15076
15077
15078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
15079   void * jresult ;
15080   Dali::HoverEvent *arg1 = 0 ;
15081   Dali::HoverEvent *result = 0 ;
15082
15083   arg1 = (Dali::HoverEvent *)jarg1;
15084   if (!arg1) {
15085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
15086     return 0;
15087   }
15088   {
15089     try {
15090       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
15091     } CALL_CATCH_EXCEPTION(0);
15092   }
15093
15094   jresult = (void *)result;
15095   return jresult;
15096 }
15097
15098
15099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
15100   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15101
15102   arg1 = (Dali::HoverEvent *)jarg1;
15103   {
15104     try {
15105       delete arg1;
15106     } CALL_CATCH_EXCEPTION();
15107   }
15108
15109 }
15110
15111
15112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
15113   void * jresult ;
15114   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15115   Dali::HoverEvent *arg2 = 0 ;
15116   Dali::HoverEvent *result = 0 ;
15117
15118   arg1 = (Dali::HoverEvent *)jarg1;
15119   arg2 = (Dali::HoverEvent *)jarg2;
15120   if (!arg2) {
15121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
15122     return 0;
15123   }
15124   {
15125     try {
15126       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
15127     } catch (std::out_of_range& e) {
15128       {
15129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15130       };
15131     } catch (std::exception& e) {
15132       {
15133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15134       };
15135     } catch (Dali::DaliException e) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15138       };
15139     } catch (...) {
15140       {
15141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15142       };
15143     }
15144   }
15145
15146   jresult = (void *)result;
15147   return jresult;
15148 }
15149
15150
15151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
15152   void * jresult ;
15153   unsigned int arg1 ;
15154   Dali::HoverEvent result;
15155
15156   arg1 = (unsigned int)jarg1;
15157   {
15158     try {
15159       result = DevelHoverEvent::New(arg1);
15160     } CALL_CATCH_EXCEPTION(0);
15161   }
15162
15163   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
15164   return jresult;
15165 }
15166
15167
15168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
15169   unsigned long jresult ;
15170   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15171   unsigned long result;
15172
15173   arg1 = (Dali::HoverEvent *)jarg1;
15174   {
15175     try {
15176       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
15177     } catch (std::out_of_range& e) {
15178       {
15179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15180       };
15181     } catch (std::exception& e) {
15182       {
15183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15184       };
15185     } catch (Dali::DaliException e) {
15186       {
15187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15188       };
15189     } catch (...) {
15190       {
15191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15192       };
15193     }
15194   }
15195
15196   jresult = (unsigned long)result;
15197   return jresult;
15198 }
15199
15200
15201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
15202   unsigned long jresult ;
15203   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15204   std::size_t result;
15205
15206   arg1 = (Dali::HoverEvent *)jarg1;
15207   {
15208     try {
15209       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
15210     } catch (std::out_of_range& e) {
15211       {
15212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15213       };
15214     } catch (std::exception& e) {
15215       {
15216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15217       };
15218     } catch (Dali::DaliException e) {
15219       {
15220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15221       };
15222     } catch (...) {
15223       {
15224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15225       };
15226     }
15227   }
15228
15229   jresult = (unsigned long)result;
15230   return jresult;
15231 }
15232
15233
15234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
15235   int jresult ;
15236   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15237   std::size_t arg2 ;
15238   int32_t result;
15239
15240   arg1 = (Dali::HoverEvent *)jarg1;
15241   arg2 = (std::size_t)jarg2;
15242   {
15243     try {
15244       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
15245     } catch (std::out_of_range& e) {
15246       {
15247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15248       };
15249     } catch (std::exception& e) {
15250       {
15251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15252       };
15253     } catch (Dali::DaliException e) {
15254       {
15255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15256       };
15257     } catch (...) {
15258       {
15259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15260       };
15261     }
15262   }
15263
15264   jresult = result;
15265   return jresult;
15266 }
15267
15268
15269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
15270   int jresult ;
15271   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15272   std::size_t arg2 ;
15273   Dali::PointState::Type result;
15274
15275   arg1 = (Dali::HoverEvent *)jarg1;
15276   arg2 = (std::size_t)jarg2;
15277   {
15278     try {
15279       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
15280     } CALL_CATCH_EXCEPTION(0);
15281   }
15282
15283   jresult = (int)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
15289   void * jresult ;
15290   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15291   std::size_t arg2 ;
15292   Dali::Actor result;
15293
15294   arg1 = (Dali::HoverEvent *)jarg1;
15295   arg2 = (std::size_t)jarg2;
15296   {
15297     try {
15298       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
15299     } catch (std::out_of_range& e) {
15300       {
15301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (std::exception& e) {
15304       {
15305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (Dali::DaliException e) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317
15318   jresult = new Dali::Actor((const Dali::Actor &)result);
15319   return jresult;
15320 }
15321
15322
15323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
15324   void * jresult ;
15325   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15326   std::size_t arg2 ;
15327   Dali::Vector2 *result = 0 ;
15328
15329   arg1 = (Dali::HoverEvent *)jarg1;
15330   arg2 = (std::size_t)jarg2;
15331   {
15332     try {
15333       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
15334     } catch (std::out_of_range& e) {
15335       {
15336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (std::exception& e) {
15339       {
15340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (Dali::DaliException e) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352
15353   jresult = (void *)result;
15354   return jresult;
15355 }
15356
15357
15358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
15359   void * jresult ;
15360   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
15361   std::size_t arg2 ;
15362   Dali::Vector2 *result = 0 ;
15363
15364   arg1 = (Dali::HoverEvent *)jarg1;
15365   arg2 = (std::size_t)jarg2;
15366   {
15367     try {
15368       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
15369     } CALL_CATCH_EXCEPTION(0);
15370   }
15371
15372   jresult = (void *)result;
15373   return jresult;
15374 }
15375
15376
15377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
15378   void * jresult ;
15379   Dali::KeyEvent *result = 0 ;
15380
15381   {
15382     try {
15383       result = (Dali::KeyEvent *)new Dali::KeyEvent();
15384     } CALL_CATCH_EXCEPTION(0);
15385   }
15386
15387   jresult = (void *)result;
15388   return jresult;
15389 }
15390
15391
15392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
15393   void * jresult ;
15394   Dali::KeyEvent *arg1 = 0 ;
15395   Dali::KeyEvent *result = 0 ;
15396
15397   arg1 = (Dali::KeyEvent *)jarg1;
15398   if (!arg1) {
15399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
15400     return 0;
15401   }
15402   {
15403     try {
15404       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
15405     } CALL_CATCH_EXCEPTION(0);
15406   }
15407
15408   jresult = (void *)result;
15409   return jresult;
15410 }
15411
15412
15413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
15414   void * jresult ;
15415   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15416   Dali::KeyEvent *arg2 = 0 ;
15417   Dali::KeyEvent *result = 0 ;
15418
15419   arg1 = (Dali::KeyEvent *)jarg1;
15420   arg2 = (Dali::KeyEvent *)jarg2;
15421   if (!arg2) {
15422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
15423     return 0;
15424   }
15425   {
15426     try {
15427       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
15428     } CALL_CATCH_EXCEPTION(0);
15429   }
15430
15431   jresult = (void *)result;
15432   return jresult;
15433 }
15434
15435
15436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
15437   void * jresult ;
15438   std::string *arg1 = 0 ;
15439   std::string *arg2 = 0 ;
15440   int arg3 ;
15441   int arg4 ;
15442   unsigned long arg5 ;
15443   Dali::KeyEvent::State *arg6 = 0 ;
15444   Dali::KeyEvent::State temp6 ;
15445   Dali::KeyEvent result;
15446
15447   if (!jarg1) {
15448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15449     return 0;
15450   }
15451   std::string arg1_str(jarg1);
15452   arg1 = &arg1_str;
15453   if (!jarg2) {
15454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15455     return 0;
15456   }
15457   std::string arg2_str(jarg2);
15458   arg2 = &arg2_str;
15459   arg3 = (int)jarg3;
15460   arg4 = (int)jarg4;
15461   arg5 = (unsigned long)jarg5;
15462   temp6 = (Dali::KeyEvent::State)jarg6;
15463   arg6 = &temp6;
15464   {
15465     try {
15466       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);
15467     } CALL_CATCH_EXCEPTION(0);
15468   }
15469
15470   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
15471
15472   //argout typemap for const std::string&
15473
15474
15475   //argout typemap for const std::string&
15476
15477   return jresult;
15478 }
15479
15480 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Key_New__SWIG_1()
15481 {
15482   void* jresult;
15483   Dali::KeyEvent result;
15484
15485   {
15486     try
15487     {
15488       result = DevelKeyEvent::New();
15489     } CALL_CATCH_EXCEPTION(0);
15490   }
15491
15492   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
15493
15494   return jresult;
15495 }
15496
15497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
15498   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15499
15500   arg1 = (Dali::KeyEvent *)jarg1;
15501   {
15502     try {
15503       delete arg1;
15504     } CALL_CATCH_EXCEPTION();
15505   }
15506
15507 }
15508
15509
15510 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
15511   bool jresult ;
15512   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15513   bool result;
15514
15515   arg1 = (Dali::KeyEvent *)jarg1;
15516   {
15517     try {
15518       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
15519     } CALL_CATCH_EXCEPTION(0);
15520   }
15521
15522   jresult = result;
15523   return jresult;
15524 }
15525
15526
15527 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
15528   bool jresult ;
15529   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15530   bool result;
15531
15532   arg1 = (Dali::KeyEvent *)jarg1;
15533   {
15534     try {
15535       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
15536     } CALL_CATCH_EXCEPTION(0);
15537   }
15538
15539   jresult = result;
15540   return jresult;
15541 }
15542
15543
15544 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
15545   bool jresult ;
15546   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15547   bool result;
15548
15549   arg1 = (Dali::KeyEvent *)jarg1;
15550   {
15551     try {
15552       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
15553     } CALL_CATCH_EXCEPTION(0);
15554   }
15555
15556   jresult = result;
15557   return jresult;
15558 }
15559
15560
15561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
15562   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15563   std::string *arg2 = 0 ;
15564
15565   argp1 = (Dali::KeyEvent *) jarg1;
15566   if (!argp1) {
15567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15568     return ;
15569   }
15570
15571   Dali::KeyEvent arg1 = *argp1;
15572   if (!jarg2) {
15573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15574     return ;
15575   }
15576   std::string arg2_str(jarg2);
15577   arg2 = &arg2_str;
15578
15579   {
15580     try {
15581       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
15582     } catch (std::out_of_range& e) {
15583       {
15584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15585       };
15586     } catch (std::exception& e) {
15587       {
15588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15589       };
15590     } catch (Dali::DaliException e) {
15591       {
15592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15593       };
15594     } catch (...) {
15595       {
15596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15597       };
15598     }
15599   }
15600 }
15601
15602
15603 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
15604   char * jresult ;
15605
15606   if( jarg1 == NULL )
15607   {
15608     jresult = SWIG_csharp_string_callback( "" );
15609   }
15610   else
15611   {
15612     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15613     std::string *result = 0;
15614     std::string str = "";
15615
15616     arg1 = ( Dali::KeyEvent * )jarg1;
15617     {
15618       try {
15619         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
15620         result = (std::string *) &str;
15621         jresult = SWIG_csharp_string_callback(result->c_str());
15622       } catch (std::out_of_range& e) {
15623         {
15624           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15625         };
15626       } catch (std::exception& e) {
15627         {
15628           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15629         };
15630       } catch (Dali::DaliException e) {
15631         {
15632           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15633         };
15634       } catch (...) {
15635         {
15636           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15637         };
15638       }
15639     }
15640
15641   }
15642
15643   return jresult;
15644 }
15645
15646
15647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
15648   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15649   std::string *arg2 = 0 ;
15650
15651   argp1 = (Dali::KeyEvent *) jarg1;
15652   if (!argp1) {
15653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15654     return ;
15655   }
15656
15657   Dali::KeyEvent arg1 = *argp1;
15658   if (!jarg2) {
15659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15660     return ;
15661   }
15662   std::string arg2_str(jarg2);
15663   arg2 = &arg2_str;
15664
15665   {
15666     try {
15667       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
15668     } catch (std::out_of_range& e) {
15669       {
15670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15671       };
15672     } catch (std::exception& e) {
15673       {
15674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15675       };
15676     } catch (Dali::DaliException e) {
15677       {
15678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15679       };
15680     } catch (...) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15683       };
15684     }
15685   }
15686 }
15687
15688
15689 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
15690   char * jresult ;
15691
15692   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15693   std::string *result = 0;
15694   std::string str = "";
15695   arg1 = ( Dali::KeyEvent * )jarg1;
15696   {
15697     try {
15698       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
15699       result = (std::string *) &str;
15700       jresult = SWIG_csharp_string_callback(result->c_str());
15701     } catch (std::out_of_range& e) {
15702       {
15703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15704       };
15705     } catch (std::exception& e) {
15706       {
15707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15708       };
15709     } catch (Dali::DaliException e) {
15710       {
15711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15712       };
15713     } catch (...) {
15714       {
15715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15716       };
15717     }
15718   }
15719
15720   return jresult;
15721 }
15722
15723
15724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
15725   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15726   int arg2 ;
15727
15728   argp1 = (Dali::KeyEvent *) jarg1;
15729   if (!argp1) {
15730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15731     return ;
15732   }
15733
15734   Dali::KeyEvent arg1 = *argp1;
15735   arg2 = (int)jarg2;
15736   {
15737     try {
15738       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
15739     } catch (std::out_of_range& e) {
15740       {
15741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15742       };
15743     } catch (std::exception& e) {
15744       {
15745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15746       };
15747     } catch (Dali::DaliException e) {
15748       {
15749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15750       };
15751     } catch (...) {
15752       {
15753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15754       };
15755     }
15756   }
15757 }
15758
15759
15760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
15761   int jresult ;
15762   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15763   int result;
15764
15765   arg1 = (Dali::KeyEvent *)jarg1;
15766   {
15767     try {
15768       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
15769     } catch (std::out_of_range& e) {
15770       {
15771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15772       };
15773     } catch (std::exception& e) {
15774       {
15775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15776       };
15777     } catch (Dali::DaliException e) {
15778       {
15779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15780       };
15781     } catch (...) {
15782       {
15783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15784       };
15785     }
15786   }
15787
15788   jresult = result;
15789   return jresult;
15790 }
15791
15792
15793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
15794   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15795   int arg2 ;
15796
15797   argp1 = (Dali::KeyEvent *) jarg1;
15798   if (!argp1) {
15799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15800     return ;
15801   }
15802
15803   Dali::KeyEvent arg1 = *argp1;
15804   arg2 = (int)jarg2;
15805   {
15806     try {
15807       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
15808     } catch (std::out_of_range& e) {
15809       {
15810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15811       };
15812     } catch (std::exception& e) {
15813       {
15814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15815       };
15816     } catch (Dali::DaliException e) {
15817       {
15818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15819       };
15820     } catch (...) {
15821       {
15822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15823       };
15824     }
15825   }
15826 }
15827
15828
15829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
15830   int jresult ;
15831   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15832   int result;
15833
15834   arg1 = (Dali::KeyEvent *)jarg1;
15835   {
15836     try {
15837       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
15838     } catch (std::out_of_range& e) {
15839       {
15840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15841       };
15842     } catch (std::exception& e) {
15843       {
15844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15845       };
15846     } catch (Dali::DaliException e) {
15847       {
15848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15849       };
15850     } catch (...) {
15851       {
15852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15853       };
15854     }
15855   }
15856
15857   jresult = result;
15858   return jresult;
15859 }
15860
15861
15862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
15863   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15864   unsigned long arg2 ;
15865
15866   argp1 = (Dali::KeyEvent *) jarg1;
15867   if (!argp1) {
15868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15869     return ;
15870   }
15871
15872   Dali::KeyEvent arg1 = *argp1;
15873   arg2 = (int)jarg2;
15874   {
15875     try {
15876       Dali::DevelKeyEvent::SetTime(arg1, arg2);
15877     } catch (std::out_of_range& e) {
15878       {
15879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15880       };
15881     } catch (std::exception& e) {
15882       {
15883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15884       };
15885     } catch (Dali::DaliException e) {
15886       {
15887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15888       };
15889     } catch (...) {
15890       {
15891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15892       };
15893     }
15894   }
15895 }
15896
15897
15898 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
15899   unsigned long jresult ;
15900   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15901   unsigned long result;
15902
15903   arg1 = (Dali::KeyEvent *)jarg1;
15904   {
15905     try {
15906       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
15907     } catch (std::out_of_range& e) {
15908       {
15909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (std::exception& e) {
15912       {
15913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15914       };
15915     } catch (Dali::DaliException e) {
15916       {
15917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15918       };
15919     } catch (...) {
15920       {
15921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15922       };
15923     }
15924   }
15925
15926   jresult = result;
15927   return jresult;
15928 }
15929
15930
15931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
15932   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
15933   Dali::KeyEvent::State arg2;
15934
15935   argp1 = (Dali::KeyEvent *) jarg1;
15936   if (!argp1) {
15937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15938     return ;
15939   }
15940
15941   Dali::KeyEvent arg1 = *argp1;
15942   arg2 = (Dali::KeyEvent::State)jarg2;
15943   {
15944     try {
15945       Dali::DevelKeyEvent::SetState(arg1, arg2);
15946     } catch (std::out_of_range& e) {
15947       {
15948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15949       };
15950     } catch (std::exception& e) {
15951       {
15952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15953       };
15954     } catch (Dali::DaliException e) {
15955       {
15956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15957       };
15958     } catch (...) {
15959       {
15960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15961       };
15962     }
15963   }
15964 }
15965
15966
15967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
15968   int jresult ;
15969   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15970   Dali::KeyEvent::State result;
15971
15972   arg1 = (Dali::KeyEvent *)jarg1;
15973   {
15974     try {
15975       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
15976     } catch (std::out_of_range& e) {
15977       {
15978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15979       };
15980     } catch (std::exception& e) {
15981       {
15982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15983       };
15984     } catch (Dali::DaliException e) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15987       };
15988     } catch (...) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15991       };
15992     }
15993   }
15994
15995   jresult = (int)result;
15996   return jresult;
15997
15998 }
15999
16000 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
16001   char * jresult ;
16002
16003   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
16004   std::string *result = 0;
16005   std::string str = "";
16006
16007   arg1 = ( Dali::KeyEvent * )jarg1;
16008   {
16009     try {
16010       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
16011       result = (std::string *) &str;
16012       jresult = SWIG_csharp_string_callback(result->c_str());
16013     } CALL_CATCH_EXCEPTION(0);
16014   }
16015
16016   return jresult;
16017 }
16018
16019
16020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
16021   void * jresult ;
16022   Dali::LongPressGestureDetector *result = 0 ;
16023
16024   {
16025     try {
16026       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
16027     } CALL_CATCH_EXCEPTION(0);
16028   }
16029
16030   jresult = (void *)result;
16031   return jresult;
16032 }
16033
16034
16035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
16036   void * jresult ;
16037   Dali::LongPressGestureDetector result;
16038
16039   {
16040     try {
16041       result = Dali::LongPressGestureDetector::New();
16042     } CALL_CATCH_EXCEPTION(0);
16043   }
16044
16045   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16046   return jresult;
16047 }
16048
16049
16050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
16051   void * jresult ;
16052   unsigned int arg1 ;
16053   Dali::LongPressGestureDetector result;
16054
16055   arg1 = (unsigned int)jarg1;
16056   {
16057     try {
16058       result = Dali::LongPressGestureDetector::New(arg1);
16059     } CALL_CATCH_EXCEPTION(0);
16060   }
16061
16062   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16063   return jresult;
16064 }
16065
16066
16067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
16068   void * jresult ;
16069   unsigned int arg1 ;
16070   unsigned int arg2 ;
16071   Dali::LongPressGestureDetector result;
16072
16073   arg1 = (unsigned int)jarg1;
16074   arg2 = (unsigned int)jarg2;
16075   {
16076     try {
16077       result = Dali::LongPressGestureDetector::New(arg1,arg2);
16078     } CALL_CATCH_EXCEPTION(0);
16079   }
16080
16081   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16082   return jresult;
16083 }
16084
16085
16086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
16087   void * jresult ;
16088   Dali::BaseHandle arg1 ;
16089   Dali::BaseHandle *argp1 ;
16090   Dali::LongPressGestureDetector result;
16091
16092   argp1 = (Dali::BaseHandle *)jarg1;
16093   if (!argp1) {
16094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
16095     return 0;
16096   }
16097   arg1 = *argp1;
16098   {
16099     try {
16100       result = Dali::LongPressGestureDetector::DownCast(arg1);
16101     } CALL_CATCH_EXCEPTION(0);
16102   }
16103
16104   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
16105   return jresult;
16106 }
16107
16108
16109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
16110   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16111
16112   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16113   {
16114     try {
16115       delete arg1;
16116     } CALL_CATCH_EXCEPTION();
16117   }
16118
16119 }
16120
16121
16122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
16123   void * jresult ;
16124   Dali::LongPressGestureDetector *arg1 = 0 ;
16125   Dali::LongPressGestureDetector *result = 0 ;
16126
16127   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16128   if (!arg1) {
16129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
16130     return 0;
16131   }
16132   {
16133     try {
16134       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
16135     } CALL_CATCH_EXCEPTION(0);
16136   }
16137
16138   jresult = (void *)result;
16139   return jresult;
16140 }
16141
16142
16143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
16144   void * jresult ;
16145   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16146   Dali::LongPressGestureDetector *arg2 = 0 ;
16147   Dali::LongPressGestureDetector *result = 0 ;
16148
16149   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16150   arg2 = (Dali::LongPressGestureDetector *)jarg2;
16151   if (!arg2) {
16152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
16153     return 0;
16154   }
16155   {
16156     try {
16157       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
16158     } CALL_CATCH_EXCEPTION(0);
16159   }
16160
16161   jresult = (void *)result;
16162   return jresult;
16163 }
16164
16165
16166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
16167   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16168   unsigned int arg2 ;
16169
16170   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16171   arg2 = (unsigned int)jarg2;
16172   {
16173     try {
16174       (arg1)->SetTouchesRequired(arg2);
16175     } CALL_CATCH_EXCEPTION();
16176   }
16177
16178 }
16179
16180
16181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
16182   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16183   unsigned int arg2 ;
16184   unsigned int arg3 ;
16185
16186   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16187   arg2 = (unsigned int)jarg2;
16188   arg3 = (unsigned int)jarg3;
16189   {
16190     try {
16191       (arg1)->SetTouchesRequired(arg2,arg3);
16192     } CALL_CATCH_EXCEPTION();
16193   }
16194
16195 }
16196
16197
16198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
16199   unsigned int jresult ;
16200   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16201   unsigned int result;
16202
16203   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16204   {
16205     try {
16206       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
16207     } CALL_CATCH_EXCEPTION(0);
16208   }
16209
16210   jresult = result;
16211   return jresult;
16212 }
16213
16214
16215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
16216   unsigned int jresult ;
16217   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16218   unsigned int result;
16219
16220   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16221   {
16222     try {
16223       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
16224     } CALL_CATCH_EXCEPTION(0);
16225   }
16226
16227   jresult = result;
16228   return jresult;
16229 }
16230
16231
16232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
16233   void * jresult ;
16234   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
16235   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
16236
16237   arg1 = (Dali::LongPressGestureDetector *)jarg1;
16238   {
16239     try {
16240       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
16241     } CALL_CATCH_EXCEPTION(0);
16242   }
16243
16244   jresult = (void *)result;
16245   return jresult;
16246 }
16247
16248
16249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
16250   void * jresult ;
16251   Dali::LongPressGesture *result = 0 ;
16252
16253   {
16254     try {
16255       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
16256     } CALL_CATCH_EXCEPTION(0);
16257   }
16258
16259   jresult = (void *)result;
16260   return jresult;
16261 }
16262
16263
16264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
16265   void * jresult ;
16266   Dali::GestureState arg1 ;
16267   Dali::LongPressGesture result;
16268
16269   arg1 = (Dali::GestureState)jarg1;
16270   {
16271     try {
16272       result = DevelLongPressGesture::New(arg1);
16273     } CALL_CATCH_EXCEPTION(0);
16274   }
16275
16276   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
16277   return jresult;
16278 }
16279
16280
16281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
16282   void * jresult ;
16283   Dali::LongPressGesture *arg1 = 0 ;
16284   Dali::LongPressGesture *result = 0 ;
16285
16286   arg1 = (Dali::LongPressGesture *)jarg1;
16287   if (!arg1) {
16288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
16289     return 0;
16290   }
16291   {
16292     try {
16293       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
16294     } CALL_CATCH_EXCEPTION(0);
16295   }
16296
16297   jresult = (void *)result;
16298   return jresult;
16299 }
16300
16301
16302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
16303   void * jresult ;
16304   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16305   Dali::LongPressGesture *arg2 = 0 ;
16306   Dali::LongPressGesture *result = 0 ;
16307
16308   arg1 = (Dali::LongPressGesture *)jarg1;
16309   arg2 = (Dali::LongPressGesture *)jarg2;
16310   if (!arg2) {
16311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
16312     return 0;
16313   }
16314   {
16315     try {
16316       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
16317     } CALL_CATCH_EXCEPTION(0);
16318   }
16319
16320   jresult = (void *)result;
16321   return jresult;
16322 }
16323
16324
16325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
16326   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16327
16328   arg1 = (Dali::LongPressGesture *)jarg1;
16329   {
16330     try {
16331       delete arg1;
16332     } CALL_CATCH_EXCEPTION();
16333   }
16334
16335 }
16336
16337
16338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
16339   unsigned int jresult ;
16340   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16341   unsigned int result;
16342
16343   arg1 = (Dali::LongPressGesture *)jarg1;
16344   result = (unsigned int) ((arg1)->GetNumberOfTouches());
16345   jresult = result;
16346   return jresult;
16347 }
16348
16349
16350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
16351   void * jresult ;
16352   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16353   Dali::Vector2 result;
16354
16355   arg1 = (Dali::LongPressGesture *)jarg1;
16356   {
16357     try {
16358       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
16359     } catch (std::out_of_range& e) {
16360       {
16361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (std::exception& e) {
16364       {
16365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16366       };
16367     } catch (Dali::DaliException e) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16370       };
16371     } catch (...) {
16372       {
16373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16374       };
16375     }
16376   }
16377   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
16383   void * jresult ;
16384   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
16385   Dali::Vector2 result;
16386
16387   arg1 = (Dali::LongPressGesture *)jarg1;
16388   {
16389     try {
16390       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
16391     } catch (std::out_of_range& e) {
16392       {
16393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16394       };
16395     } catch (std::exception& e) {
16396       {
16397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16398       };
16399     } catch (Dali::DaliException e) {
16400       {
16401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16402       };
16403     } catch (...) {
16404       {
16405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16406       };
16407     }
16408   }
16409   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16410   return jresult;
16411 }
16412
16413
16414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
16415   void * jresult ;
16416   Dali::WheelEvent *result = 0 ;
16417
16418   {
16419     try {
16420       result = (Dali::WheelEvent *)new Dali::WheelEvent();
16421     } CALL_CATCH_EXCEPTION(0);
16422   }
16423
16424   jresult = (void *)result;
16425   return jresult;
16426 }
16427
16428
16429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
16430   void * jresult ;
16431   Dali::WheelEvent *arg1 = 0 ;
16432   Dali::WheelEvent *result = 0 ;
16433
16434   arg1 = (Dali::WheelEvent *)jarg1;
16435   if (!arg1) {
16436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
16437     return 0;
16438   }
16439   {
16440     try {
16441       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
16467   void * jresult ;
16468   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16469   Dali::WheelEvent *arg2 = 0 ;
16470   Dali::WheelEvent *result = 0 ;
16471
16472   arg1 = (Dali::WheelEvent *)jarg1;
16473   arg2 = (Dali::WheelEvent *)jarg2;
16474   if (!arg2) {
16475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
16476     return 0;
16477   }
16478   {
16479     try {
16480       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
16481     } catch (std::out_of_range& e) {
16482       {
16483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16484       };
16485     } catch (std::exception& e) {
16486       {
16487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16488       };
16489     } catch (Dali::DaliException e) {
16490       {
16491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16492       };
16493     } catch (...) {
16494       {
16495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16496       };
16497     }
16498   }
16499
16500   jresult = (void *)result;
16501   return jresult;
16502 }
16503
16504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
16505   void * jresult ;
16506   Dali::WheelEvent::Type arg1 ;
16507   int arg2 ;
16508   unsigned int arg3 ;
16509   Dali::Vector2 arg4 ;
16510   int arg5 ;
16511   unsigned int arg6 ;
16512   Dali::Vector2 *argp4 ;
16513   Dali::WheelEvent result;
16514
16515   arg1 = (Dali::WheelEvent::Type)jarg1;
16516   arg2 = (int)jarg2;
16517   arg3 = (unsigned int)jarg3;
16518   argp4 = (Dali::Vector2 *)jarg4;
16519   if (!argp4) {
16520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
16521     return 0;
16522   }
16523   arg4 = *argp4;
16524   arg5 = (int)jarg5;
16525   arg6 = (unsigned int)jarg6;
16526   {
16527     try {
16528       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
16529     } CALL_CATCH_EXCEPTION(0);
16530   }
16531
16532   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
16533   return jresult;
16534 }
16535
16536
16537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
16538   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16539
16540   arg1 = (Dali::WheelEvent *)jarg1;
16541   {
16542     try {
16543       delete arg1;
16544     } CALL_CATCH_EXCEPTION();
16545   }
16546
16547 }
16548
16549
16550 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
16551   bool jresult ;
16552   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16553   bool result;
16554
16555   arg1 = (Dali::WheelEvent *)jarg1;
16556   {
16557     try {
16558       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
16559     } CALL_CATCH_EXCEPTION(0);
16560   }
16561
16562   jresult = result;
16563   return jresult;
16564 }
16565
16566
16567 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
16568   bool jresult ;
16569   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16570   bool result;
16571
16572   arg1 = (Dali::WheelEvent *)jarg1;
16573   {
16574     try {
16575       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
16576     } catch (std::out_of_range& e) {
16577       {
16578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16579       };
16580     } catch (std::exception& e) {
16581       {
16582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (Dali::DaliException e) {
16585       {
16586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16591       };
16592     }
16593   }
16594
16595   jresult = result;
16596   return jresult;
16597 }
16598
16599
16600 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
16601   bool jresult ;
16602   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16603   bool result;
16604
16605   arg1 = (Dali::WheelEvent *)jarg1;
16606   {
16607     try {
16608       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
16609     } catch (std::out_of_range& e) {
16610       {
16611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16612       };
16613     } catch (std::exception& e) {
16614       {
16615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16616       };
16617     } catch (Dali::DaliException e) {
16618       {
16619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16620       };
16621     } catch (...) {
16622       {
16623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16624       };
16625     }
16626   }
16627
16628   jresult = result;
16629   return jresult;
16630 }
16631
16632
16633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
16634   int jresult ;
16635   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16636   Dali::WheelEvent::Type result;
16637
16638   arg1 = (Dali::WheelEvent *)jarg1;
16639   {
16640     try {
16641       result = ((Dali::WheelEvent const *)arg1)->GetType();
16642     } catch (std::out_of_range& e) {
16643       {
16644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16645       };
16646     } catch (std::exception& e) {
16647       {
16648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16649       };
16650     } catch (Dali::DaliException e) {
16651       {
16652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16653       };
16654     } catch (...) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16657       };
16658     }
16659   }
16660
16661   jresult = (int)result;
16662   return jresult;
16663 }
16664
16665
16666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
16667   int jresult ;
16668   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16669   int result;
16670
16671   arg1 = (Dali::WheelEvent *)jarg1;
16672   {
16673     try {
16674       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
16675     } catch (std::out_of_range& e) {
16676       {
16677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16678       };
16679     } catch (std::exception& e) {
16680       {
16681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16682       };
16683     } catch (Dali::DaliException e) {
16684       {
16685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16686       };
16687     } catch (...) {
16688       {
16689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16690       };
16691     }
16692   }
16693
16694   jresult = result;
16695   return jresult;
16696 }
16697
16698
16699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
16700   unsigned int jresult ;
16701   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16702   unsigned int result;
16703
16704   arg1 = (Dali::WheelEvent *)jarg1;
16705   {
16706     try {
16707       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
16708     } CALL_CATCH_EXCEPTION(0);
16709   }
16710
16711   jresult = result;
16712   return jresult;
16713 }
16714
16715
16716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
16717   void * jresult ;
16718   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16719   Dali::Vector2 *result = 0 ;
16720
16721   arg1 = (Dali::WheelEvent *)jarg1;
16722   {
16723     try {
16724       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
16725     } CALL_CATCH_EXCEPTION(0);
16726   }
16727
16728   jresult = (void *)result;
16729   return jresult;
16730 }
16731
16732
16733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
16734   int jresult ;
16735   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16736   int result;
16737
16738   arg1 = (Dali::WheelEvent *)jarg1;
16739   {
16740     try {
16741       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
16742     } catch (std::out_of_range& e) {
16743       {
16744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16745       };
16746     } catch (std::exception& e) {
16747       {
16748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16749       };
16750     } catch (Dali::DaliException e) {
16751       {
16752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16753       };
16754     } catch (...) {
16755       {
16756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16757       };
16758     }
16759   }
16760
16761   jresult = result;
16762   return jresult;
16763 }
16764
16765
16766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
16767   unsigned int jresult ;
16768   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16769   unsigned int result;
16770
16771   arg1 = (Dali::WheelEvent *)jarg1;
16772   {
16773     try {
16774       result = ((Dali::WheelEvent const *)arg1)->GetTime();
16775     } catch (std::out_of_range& e) {
16776       {
16777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16778       };
16779     } catch (std::exception& e) {
16780       {
16781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16782       };
16783     } catch (Dali::DaliException e) {
16784       {
16785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16786       };
16787     } catch (...) {
16788       {
16789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16790       };
16791     }
16792   }
16793
16794   jresult = result;
16795   return jresult;
16796 }
16797
16798 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
16799   char * jresult ;
16800   Dali::KeyEvent *arg1 = 0 ;
16801   std::string result;
16802
16803   arg1 = (Dali::KeyEvent *)jarg1;
16804   if (!arg1) {
16805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16806     return 0;
16807   }
16808   {
16809     try {
16810       result = arg1->GetDeviceName();
16811     } CALL_CATCH_EXCEPTION(0);
16812   }
16813
16814   jresult = SWIG_csharp_string_callback((&result)->c_str());
16815   return jresult;
16816 }
16817
16818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
16819   int jresult ;
16820   Dali::KeyEvent *arg1 = 0 ;
16821   Dali::Device::Class::Type result;
16822
16823   arg1 = (Dali::KeyEvent *)jarg1;
16824   if (!arg1) {
16825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16826     return 0;
16827   }
16828   {
16829     try {
16830       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
16831     } CALL_CATCH_EXCEPTION(0);
16832   }
16833
16834   jresult = (int)result;
16835   return jresult;
16836 }
16837
16838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
16839   int jresult ;
16840   Dali::KeyEvent *arg1 = 0 ;
16841   Dali::Device::Subclass::Type result;
16842
16843   arg1 = (Dali::KeyEvent *)jarg1;
16844   if (!arg1) {
16845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16846     return 0;
16847   }
16848   {
16849     try {
16850       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
16851     } CALL_CATCH_EXCEPTION(0);
16852   }
16853
16854   jresult = (int)result;
16855   return jresult;
16856 }
16857
16858
16859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
16860   void * jresult ;
16861   Dali::Stage result;
16862
16863   {
16864     try {
16865       result = Dali::Stage::GetCurrent();
16866     } CALL_CATCH_EXCEPTION(0);
16867   }
16868
16869   jresult = new Dali::Stage((const Dali::Stage &)result);
16870   return jresult;
16871 }
16872
16873
16874 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
16875   bool jresult ;
16876   bool result;
16877
16878   {
16879     try {
16880       result = (bool)Dali::Stage::IsInstalled();
16881     } CALL_CATCH_EXCEPTION(0);
16882   }
16883
16884   jresult = result;
16885   return jresult;
16886 }
16887
16888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
16889   void * jresult ;
16890   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16891   Dali::RenderTaskList result;
16892
16893   arg1 = (Dali::Stage *)jarg1;
16894   {
16895     try {
16896       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
16897     } CALL_CATCH_EXCEPTION(0);
16898   }
16899
16900   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
16901   return jresult;
16902 }
16903
16904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
16905   void * jresult ;
16906   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16907   Dali::Vector2 result;
16908
16909   arg1 = (Dali::Stage *)jarg1;
16910   {
16911     try {
16912       result = ((Dali::Stage const *)arg1)->GetDpi();
16913     } CALL_CATCH_EXCEPTION(0);
16914   }
16915
16916   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16917   return jresult;
16918 }
16919
16920
16921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
16922   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16923   float arg2 ;
16924
16925   arg1 = (Dali::Stage *)jarg1;
16926   arg2 = (float)jarg2;
16927   {
16928     try {
16929       (arg1)->KeepRendering(arg2);
16930     } CALL_CATCH_EXCEPTION();
16931   }
16932
16933 }
16934
16935
16936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
16937   void * jresult ;
16938   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16939   Dali::Stage::KeyEventSignalType *result = 0 ;
16940
16941   arg1 = (Dali::Stage *)jarg1;
16942   {
16943     try {
16944       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
16945     } CALL_CATCH_EXCEPTION(0);
16946   }
16947
16948   jresult = (void *)result;
16949   return jresult;
16950 }
16951
16952
16953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
16954   void * jresult ;
16955   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16956   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
16957
16958   arg1 = (Dali::Stage *)jarg1;
16959   {
16960     try {
16961       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
16962     } CALL_CATCH_EXCEPTION(0);
16963   }
16964
16965   jresult = (void *)result;
16966   return jresult;
16967 }
16968
16969
16970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
16971   void * jresult ;
16972   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16973   Dali::Stage::TouchEventSignalType *result = 0 ;
16974
16975   arg1 = (Dali::Stage *)jarg1;
16976   {
16977     try {
16978       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
16979     } CALL_CATCH_EXCEPTION(0);
16980   }
16981
16982   jresult = (void *)result;
16983   return jresult;
16984 }
16985
16986
16987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
16988   void * jresult ;
16989   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16990   Dali::Stage::WheelEventSignalType *result = 0 ;
16991
16992   arg1 = (Dali::Stage *)jarg1;
16993   {
16994     try {
16995       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
16996     } CALL_CATCH_EXCEPTION(0);
16997   }
16998
16999   jresult = (void *)result;
17000   return jresult;
17001 }
17002
17003
17004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
17005   void * jresult ;
17006   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17007   Dali::Stage::ContextStatusSignal *result = 0 ;
17008
17009   arg1 = (Dali::Stage *)jarg1;
17010   {
17011     try {
17012       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
17013     } CALL_CATCH_EXCEPTION(0);
17014   }
17015
17016   jresult = (void *)result;
17017   return jresult;
17018 }
17019
17020
17021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
17022   void * jresult ;
17023   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17024   Dali::Stage::ContextStatusSignal *result = 0 ;
17025
17026   arg1 = (Dali::Stage *)jarg1;
17027   {
17028     try {
17029       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
17030     } CALL_CATCH_EXCEPTION(0);
17031   }
17032
17033   jresult = (void *)result;
17034   return jresult;
17035 }
17036
17037
17038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
17039   void * jresult ;
17040   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17041   Dali::Stage::SceneCreatedSignalType *result = 0 ;
17042
17043   arg1 = (Dali::Stage *)jarg1;
17044   {
17045     try {
17046       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
17047     } CALL_CATCH_EXCEPTION(0);
17048   }
17049
17050   jresult = (void *)result;
17051   return jresult;
17052 }
17053
17054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
17055   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17056   Dali::DevelStage::Rendering arg2 ;
17057
17058   arg1 = (Dali::Stage *)jarg1;
17059   arg2 = (Dali::DevelStage::Rendering)jarg2;
17060   {
17061     try {
17062       DevelStage::SetRenderingBehavior(*arg1,arg2);
17063     } CALL_CATCH_EXCEPTION();
17064   }
17065
17066 }
17067
17068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
17069
17070   int jresult ;
17071   int result ;
17072   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
17073
17074   arg1 = (Dali::Stage *)jarg1;
17075   {
17076     try {
17077       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
17078     } CALL_CATCH_EXCEPTION(0);
17079   }
17080
17081   jresult = result;
17082   return jresult;
17083 }
17084
17085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
17086   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
17087
17088   arg1 = (Dali::RelayoutContainer *)jarg1;
17089   {
17090     try {
17091       delete arg1;
17092     } CALL_CATCH_EXCEPTION();
17093   }
17094
17095 }
17096
17097
17098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
17099   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
17100   Dali::Actor *arg2 = 0 ;
17101   Dali::Vector2 *arg3 = 0 ;
17102
17103   arg1 = (Dali::RelayoutContainer *)jarg1;
17104   arg2 = (Dali::Actor *)jarg2;
17105   if (!arg2) {
17106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
17107     return ;
17108   }
17109   arg3 = (Dali::Vector2 *)jarg3;
17110   if (!arg3) {
17111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
17112     return ;
17113   }
17114   {
17115     try {
17116       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
17117     } CALL_CATCH_EXCEPTION();
17118   }
17119
17120 }
17121
17122
17123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
17124   void * jresult ;
17125   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17126   Dali::CustomActor result;
17127
17128   arg1 = (Dali::CustomActorImpl *)jarg1;
17129   {
17130     try {
17131       result = ((Dali::CustomActorImpl const *)arg1)->Self();
17132     } CALL_CATCH_EXCEPTION(0);
17133   }
17134
17135   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
17136   return jresult;
17137 }
17138
17139
17140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
17141   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17142   int arg2 ;
17143
17144   arg1 = (Dali::CustomActorImpl *)jarg1;
17145   arg2 = (int)jarg2;
17146   {
17147     try {
17148       (arg1)->OnSceneConnection(arg2);
17149     } CALL_CATCH_EXCEPTION();
17150   }
17151
17152 }
17153
17154
17155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
17156   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17157
17158   arg1 = (Dali::CustomActorImpl *)jarg1;
17159   {
17160     try {
17161       (arg1)->OnSceneDisconnection();
17162     } CALL_CATCH_EXCEPTION();
17163   }
17164
17165 }
17166
17167
17168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
17169   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17170   Dali::Actor *arg2 = 0 ;
17171
17172   arg1 = (Dali::CustomActorImpl *)jarg1;
17173   arg2 = (Dali::Actor *)jarg2;
17174   if (!arg2) {
17175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
17176     return ;
17177   }
17178   {
17179     try {
17180       (arg1)->OnChildAdd(*arg2);
17181     } CALL_CATCH_EXCEPTION();
17182   }
17183
17184 }
17185
17186
17187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
17188   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17189   Dali::Actor *arg2 = 0 ;
17190
17191   arg1 = (Dali::CustomActorImpl *)jarg1;
17192   arg2 = (Dali::Actor *)jarg2;
17193   if (!arg2) {
17194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
17195     return ;
17196   }
17197   {
17198     try {
17199       (arg1)->OnChildRemove(*arg2);
17200     } CALL_CATCH_EXCEPTION();
17201   }
17202
17203 }
17204
17205
17206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
17207   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17208   Dali::Property::Index arg2 ;
17209   Dali::Property::Value arg3 ;
17210   Dali::Property::Value *argp3 ;
17211
17212   arg1 = (Dali::CustomActorImpl *)jarg1;
17213   arg2 = (Dali::Property::Index)jarg2;
17214   argp3 = (Dali::Property::Value *)jarg3;
17215   if (!argp3) {
17216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
17217     return ;
17218   }
17219   arg3 = *argp3;
17220   {
17221     try {
17222       (arg1)->OnPropertySet(arg2,arg3);
17223     } CALL_CATCH_EXCEPTION();
17224   }
17225
17226 }
17227
17228
17229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
17230   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17231   Dali::Vector3 *arg2 = 0 ;
17232
17233   arg1 = (Dali::CustomActorImpl *)jarg1;
17234   arg2 = (Dali::Vector3 *)jarg2;
17235   if (!arg2) {
17236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
17237     return ;
17238   }
17239   {
17240     try {
17241       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
17242     } CALL_CATCH_EXCEPTION();
17243   }
17244
17245 }
17246
17247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
17248   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17249   Dali::Animation *arg2 = 0 ;
17250   Dali::Vector3 *arg3 = 0 ;
17251
17252   arg1 = (Dali::CustomActorImpl *)jarg1;
17253   arg2 = (Dali::Animation *)jarg2;
17254   if (!arg2) {
17255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
17256     return ;
17257   }
17258   arg3 = (Dali::Vector3 *)jarg3;
17259   if (!arg3) {
17260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
17261     return ;
17262   }
17263   {
17264     try {
17265       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
17266     } CALL_CATCH_EXCEPTION();
17267   }
17268 }
17269
17270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
17271   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17272   Dali::Vector2 *arg2 = 0 ;
17273   Dali::RelayoutContainer *arg3 = 0 ;
17274
17275   arg1 = (Dali::CustomActorImpl *)jarg1;
17276   arg2 = (Dali::Vector2 *)jarg2;
17277   if (!arg2) {
17278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
17279     return ;
17280   }
17281   arg3 = (Dali::RelayoutContainer *)jarg3;
17282   if (!arg3) {
17283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
17284     return ;
17285   }
17286   {
17287     try {
17288       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
17289     } CALL_CATCH_EXCEPTION();
17290   }
17291
17292 }
17293
17294
17295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
17296   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17297   Dali::ResizePolicy::Type arg2 ;
17298   Dali::Dimension::Type arg3 ;
17299
17300   arg1 = (Dali::CustomActorImpl *)jarg1;
17301   arg2 = (Dali::ResizePolicy::Type)jarg2;
17302   arg3 = (Dali::Dimension::Type)jarg3;
17303   {
17304     try {
17305       (arg1)->OnSetResizePolicy(arg2,arg3);
17306     } CALL_CATCH_EXCEPTION();
17307   }
17308
17309 }
17310
17311
17312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
17313   void * jresult ;
17314   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17315   Dali::Vector3 result;
17316
17317   arg1 = (Dali::CustomActorImpl *)jarg1;
17318   {
17319     try {
17320       result = (arg1)->GetNaturalSize();
17321     } CALL_CATCH_EXCEPTION(0);
17322   }
17323
17324   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
17325   return jresult;
17326 }
17327
17328
17329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
17330   float jresult ;
17331   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17332   Dali::Actor *arg2 = 0 ;
17333   Dali::Dimension::Type arg3 ;
17334   float result;
17335
17336   arg1 = (Dali::CustomActorImpl *)jarg1;
17337   arg2 = (Dali::Actor *)jarg2;
17338   if (!arg2) {
17339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
17340     return 0;
17341   }
17342   arg3 = (Dali::Dimension::Type)jarg3;
17343   {
17344     try {
17345       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
17346     } CALL_CATCH_EXCEPTION(0);
17347   }
17348
17349   jresult = result;
17350   return jresult;
17351 }
17352
17353
17354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
17355   float jresult ;
17356   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17357   float arg2 ;
17358   float result;
17359
17360   arg1 = (Dali::CustomActorImpl *)jarg1;
17361   arg2 = (float)jarg2;
17362   {
17363     try {
17364       result = (float)(arg1)->GetHeightForWidth(arg2);
17365     } CALL_CATCH_EXCEPTION(0);
17366   }
17367
17368   jresult = result;
17369   return jresult;
17370 }
17371
17372
17373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
17374   float jresult ;
17375   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17376   float arg2 ;
17377   float result;
17378
17379   arg1 = (Dali::CustomActorImpl *)jarg1;
17380   arg2 = (float)jarg2;
17381   {
17382     try {
17383       result = (float)(arg1)->GetWidthForHeight(arg2);
17384     } CALL_CATCH_EXCEPTION(0);
17385   }
17386
17387   jresult = result;
17388   return jresult;
17389 }
17390
17391
17392 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
17393   bool jresult ;
17394   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17395   Dali::Dimension::Type arg2 ;
17396   bool result;
17397
17398   arg1 = (Dali::CustomActorImpl *)jarg1;
17399   arg2 = (Dali::Dimension::Type)jarg2;
17400   {
17401     try {
17402       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
17403     } CALL_CATCH_EXCEPTION(0);
17404   }
17405
17406   jresult = result;
17407   return jresult;
17408 }
17409
17410
17411 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
17412   bool jresult ;
17413   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17414   bool result;
17415
17416   arg1 = (Dali::CustomActorImpl *)jarg1;
17417   {
17418     try {
17419       result = (bool)(arg1)->RelayoutDependentOnChildren();
17420     } CALL_CATCH_EXCEPTION(0);
17421   }
17422
17423   jresult = result;
17424   return jresult;
17425 }
17426
17427
17428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
17429   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17430   Dali::Dimension::Type arg2 ;
17431
17432   arg1 = (Dali::CustomActorImpl *)jarg1;
17433   arg2 = (Dali::Dimension::Type)jarg2;
17434   {
17435     try {
17436       (arg1)->OnCalculateRelayoutSize(arg2);
17437     } CALL_CATCH_EXCEPTION();
17438   }
17439
17440 }
17441
17442
17443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
17444   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17445   float arg2 ;
17446   Dali::Dimension::Type arg3 ;
17447
17448   arg1 = (Dali::CustomActorImpl *)jarg1;
17449   arg2 = (float)jarg2;
17450   arg3 = (Dali::Dimension::Type)jarg3;
17451   {
17452     try {
17453       (arg1)->OnLayoutNegotiated(arg2,arg3);
17454     } CALL_CATCH_EXCEPTION();
17455   }
17456
17457 }
17458
17459 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
17460   bool jresult ;
17461   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17462   bool result;
17463
17464   arg1 = (Dali::CustomActorImpl *)jarg1;
17465   {
17466     try {
17467       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
17468     } CALL_CATCH_EXCEPTION(0);
17469   }
17470
17471   jresult = result;
17472   return jresult;
17473 }
17474
17475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
17476   void * jresult ;
17477   Dali::CustomActor *result = 0 ;
17478
17479   {
17480     try {
17481       result = (Dali::CustomActor *)new Dali::CustomActor();
17482     } CALL_CATCH_EXCEPTION(0);
17483   }
17484
17485   jresult = (void *)result;
17486   return jresult;
17487 }
17488
17489
17490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
17491   void * jresult ;
17492   Dali::BaseHandle arg1 ;
17493   Dali::BaseHandle *argp1 ;
17494   Dali::CustomActor result;
17495
17496   argp1 = (Dali::BaseHandle *)jarg1;
17497   if (!argp1) {
17498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17499     return 0;
17500   }
17501   arg1 = *argp1;
17502   {
17503     try {
17504       result = Dali::CustomActor::DownCast(arg1);
17505     } CALL_CATCH_EXCEPTION(0);
17506   }
17507
17508   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
17509   return jresult;
17510 }
17511
17512
17513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
17514   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17515
17516   arg1 = (Dali::CustomActor *)jarg1;
17517   {
17518     try {
17519       delete arg1;
17520     } CALL_CATCH_EXCEPTION();
17521   }
17522
17523 }
17524
17525
17526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
17527   void * jresult ;
17528   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17529   Dali::CustomActorImpl *result = 0 ;
17530
17531   arg1 = (Dali::CustomActor *)jarg1;
17532   {
17533     try {
17534       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
17535     } CALL_CATCH_EXCEPTION(0);
17536   }
17537
17538   jresult = (void *)result;
17539   return jresult;
17540 }
17541
17542
17543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
17544   void * jresult ;
17545   Dali::CustomActorImpl *arg1 = 0 ;
17546   Dali::CustomActor *result = 0 ;
17547
17548   arg1 = (Dali::CustomActorImpl *)jarg1;
17549   if (!arg1) {
17550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
17551     return 0;
17552   }
17553   {
17554     try {
17555       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
17556     } CALL_CATCH_EXCEPTION(0);
17557   }
17558
17559   jresult = (void *)result;
17560   return jresult;
17561 }
17562
17563
17564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
17565   void * jresult ;
17566   Dali::CustomActor *arg1 = 0 ;
17567   Dali::CustomActor *result = 0 ;
17568
17569   arg1 = (Dali::CustomActor *)jarg1;
17570   if (!arg1) {
17571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
17572     return 0;
17573   }
17574   {
17575     try {
17576       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
17577     } CALL_CATCH_EXCEPTION(0);
17578   }
17579
17580   jresult = (void *)result;
17581   return jresult;
17582 }
17583
17584
17585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
17586   void * jresult ;
17587   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17588   Dali::CustomActor *arg2 = 0 ;
17589   Dali::CustomActor *result = 0 ;
17590
17591   arg1 = (Dali::CustomActor *)jarg1;
17592   arg2 = (Dali::CustomActor *)jarg2;
17593   if (!arg2) {
17594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
17595     return 0;
17596   }
17597   {
17598     try {
17599       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
17600     } CALL_CATCH_EXCEPTION(0);
17601   }
17602
17603   jresult = (void *)result;
17604   return jresult;
17605 }
17606
17607
17608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
17609   int jresult ;
17610   int result;
17611
17612   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
17613   jresult = (int)result;
17614   return jresult;
17615 }
17616
17617
17618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
17619   int jresult ;
17620   int result;
17621
17622   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
17623   jresult = (int)result;
17624   return jresult;
17625 }
17626
17627
17628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
17629   int jresult ;
17630   int result;
17631
17632   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
17633   jresult = (int)result;
17634   return jresult;
17635 }
17636
17637
17638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
17639   int jresult ;
17640   int result;
17641
17642   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
17643   jresult = (int)result;
17644   return jresult;
17645 }
17646
17647
17648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
17649   int jresult ;
17650   int result;
17651
17652   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
17653   jresult = (int)result;
17654   return jresult;
17655 }
17656
17657
17658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
17659   int jresult ;
17660   int result;
17661
17662   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
17663   jresult = (int)result;
17664   return jresult;
17665 }
17666
17667
17668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
17669   int jresult ;
17670   int result;
17671
17672   result = (int)Dali::PanGestureDetector::Property::PANNING;
17673   jresult = (int)result;
17674   return jresult;
17675 }
17676
17677
17678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
17679   void * jresult ;
17680   Dali::PanGestureDetector::Property *result = 0 ;
17681
17682   {
17683     try {
17684       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
17685     } CALL_CATCH_EXCEPTION(0);
17686   }
17687
17688   jresult = (void *)result;
17689   return jresult;
17690 }
17691
17692
17693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
17694   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
17695
17696   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
17697   {
17698     try {
17699       delete arg1;
17700     } CALL_CATCH_EXCEPTION();
17701   }
17702
17703 }
17704
17705
17706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
17707   void * jresult ;
17708   Dali::Radian *result = 0 ;
17709
17710   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
17711   jresult = (void *)result;
17712   return jresult;
17713 }
17714
17715
17716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
17717   void * jresult ;
17718   Dali::Radian *result = 0 ;
17719
17720   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
17721   jresult = (void *)result;
17722   return jresult;
17723 }
17724
17725
17726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
17727   void * jresult ;
17728   Dali::Radian *result = 0 ;
17729
17730   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
17731   jresult = (void *)result;
17732   return jresult;
17733 }
17734
17735
17736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
17737   void * jresult ;
17738   Dali::Radian *result = 0 ;
17739
17740   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
17741   jresult = (void *)result;
17742   return jresult;
17743 }
17744
17745
17746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
17747   void * jresult ;
17748   Dali::Radian *result = 0 ;
17749
17750   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
17751   jresult = (void *)result;
17752   return jresult;
17753 }
17754
17755
17756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
17757   void * jresult ;
17758   Dali::Radian *result = 0 ;
17759
17760   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
17761   jresult = (void *)result;
17762   return jresult;
17763 }
17764
17765
17766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
17767   void * jresult ;
17768   Dali::Radian *result = 0 ;
17769
17770   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
17771   jresult = (void *)result;
17772   return jresult;
17773 }
17774
17775
17776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
17777   void * jresult ;
17778   Dali::PanGestureDetector *result = 0 ;
17779
17780   {
17781     try {
17782       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
17783     } CALL_CATCH_EXCEPTION(0);
17784   }
17785
17786   jresult = (void *)result;
17787   return jresult;
17788 }
17789
17790
17791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
17792   void * jresult ;
17793   Dali::PanGestureDetector result;
17794
17795   {
17796     try {
17797       result = Dali::PanGestureDetector::New();
17798     } CALL_CATCH_EXCEPTION(0);
17799   }
17800
17801   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
17807   void * jresult ;
17808   Dali::BaseHandle arg1 ;
17809   Dali::BaseHandle *argp1 ;
17810   Dali::PanGestureDetector result;
17811
17812   argp1 = (Dali::BaseHandle *)jarg1;
17813   if (!argp1) {
17814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17815     return 0;
17816   }
17817   arg1 = *argp1;
17818   {
17819     try {
17820       result = Dali::PanGestureDetector::DownCast(arg1);
17821     } CALL_CATCH_EXCEPTION(0);
17822   }
17823
17824   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
17825   return jresult;
17826 }
17827
17828
17829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
17830   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17831
17832   arg1 = (Dali::PanGestureDetector *)jarg1;
17833   {
17834     try {
17835       delete arg1;
17836     } CALL_CATCH_EXCEPTION();
17837   }
17838
17839 }
17840
17841
17842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
17843   void * jresult ;
17844   Dali::PanGestureDetector *arg1 = 0 ;
17845   Dali::PanGestureDetector *result = 0 ;
17846
17847   arg1 = (Dali::PanGestureDetector *)jarg1;
17848   if (!arg1) {
17849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
17850     return 0;
17851   }
17852   {
17853     try {
17854       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
17855     } CALL_CATCH_EXCEPTION(0);
17856   }
17857
17858   jresult = (void *)result;
17859   return jresult;
17860 }
17861
17862
17863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
17864   void * jresult ;
17865   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17866   Dali::PanGestureDetector *arg2 = 0 ;
17867   Dali::PanGestureDetector *result = 0 ;
17868
17869   arg1 = (Dali::PanGestureDetector *)jarg1;
17870   arg2 = (Dali::PanGestureDetector *)jarg2;
17871   if (!arg2) {
17872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
17873     return 0;
17874   }
17875   {
17876     try {
17877       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
17878     } CALL_CATCH_EXCEPTION(0);
17879   }
17880
17881   jresult = (void *)result;
17882   return jresult;
17883 }
17884
17885
17886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
17887   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17888   unsigned int arg2 ;
17889
17890   arg1 = (Dali::PanGestureDetector *)jarg1;
17891   arg2 = (unsigned int)jarg2;
17892   {
17893     try {
17894       (arg1)->SetMinimumTouchesRequired(arg2);
17895     } CALL_CATCH_EXCEPTION();
17896   }
17897
17898 }
17899
17900
17901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
17902   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17903   unsigned int arg2 ;
17904
17905   arg1 = (Dali::PanGestureDetector *)jarg1;
17906   arg2 = (unsigned int)jarg2;
17907   {
17908     try {
17909       (arg1)->SetMaximumTouchesRequired(arg2);
17910     } CALL_CATCH_EXCEPTION();
17911   }
17912
17913 }
17914
17915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
17916   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17917   uint32_t arg2 ;
17918
17919   arg1 = (Dali::PanGestureDetector *)jarg1;
17920   arg2 = (uint32_t)jarg2;
17921   {
17922     try {
17923       (arg1)->SetMaximumMotionEventAge(arg2);
17924     } CALL_CATCH_EXCEPTION();
17925   }
17926
17927 }
17928
17929
17930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
17931   unsigned int jresult ;
17932   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17933   unsigned int result;
17934
17935   arg1 = (Dali::PanGestureDetector *)jarg1;
17936   {
17937     try {
17938       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
17939     } CALL_CATCH_EXCEPTION(0);
17940   }
17941
17942   jresult = result;
17943   return jresult;
17944 }
17945
17946
17947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
17948   unsigned int jresult ;
17949   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17950   unsigned int result;
17951
17952   arg1 = (Dali::PanGestureDetector *)jarg1;
17953   {
17954     try {
17955       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
17956     } CALL_CATCH_EXCEPTION(0);
17957   }
17958
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
17964   unsigned int jresult ;
17965   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17966   uint32_t result;
17967
17968   arg1 = (Dali::PanGestureDetector *)jarg1;
17969   {
17970     try {
17971       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
17972     } CALL_CATCH_EXCEPTION(0);
17973   }
17974
17975   jresult = result;
17976   return jresult;
17977 }
17978
17979
17980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
17981   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17982   Dali::Radian arg2 ;
17983   Dali::Radian arg3 ;
17984   Dali::Radian *argp2 ;
17985   Dali::Radian *argp3 ;
17986
17987   arg1 = (Dali::PanGestureDetector *)jarg1;
17988   argp2 = (Dali::Radian *)jarg2;
17989   if (!argp2) {
17990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17991     return ;
17992   }
17993   arg2 = *argp2;
17994   argp3 = (Dali::Radian *)jarg3;
17995   if (!argp3) {
17996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17997     return ;
17998   }
17999   arg3 = *argp3;
18000   {
18001     try {
18002       (arg1)->AddAngle(arg2,arg3);
18003     } CALL_CATCH_EXCEPTION();
18004   }
18005
18006 }
18007
18008
18009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
18010   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18011   Dali::Radian arg2 ;
18012   Dali::Radian *argp2 ;
18013
18014   arg1 = (Dali::PanGestureDetector *)jarg1;
18015   argp2 = (Dali::Radian *)jarg2;
18016   if (!argp2) {
18017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18018     return ;
18019   }
18020   arg2 = *argp2;
18021   {
18022     try {
18023       (arg1)->AddAngle(arg2);
18024     } CALL_CATCH_EXCEPTION();
18025   }
18026
18027 }
18028
18029
18030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
18031   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18032   Dali::Radian arg2 ;
18033   Dali::Radian arg3 ;
18034   Dali::Radian *argp2 ;
18035   Dali::Radian *argp3 ;
18036
18037   arg1 = (Dali::PanGestureDetector *)jarg1;
18038   argp2 = (Dali::Radian *)jarg2;
18039   if (!argp2) {
18040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18041     return ;
18042   }
18043   arg2 = *argp2;
18044   argp3 = (Dali::Radian *)jarg3;
18045   if (!argp3) {
18046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18047     return ;
18048   }
18049   arg3 = *argp3;
18050   {
18051     try {
18052       (arg1)->AddDirection(arg2,arg3);
18053     } CALL_CATCH_EXCEPTION();
18054   }
18055
18056 }
18057
18058
18059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
18060   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18061   Dali::Radian arg2 ;
18062   Dali::Radian *argp2 ;
18063
18064   arg1 = (Dali::PanGestureDetector *)jarg1;
18065   argp2 = (Dali::Radian *)jarg2;
18066   if (!argp2) {
18067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18068     return ;
18069   }
18070   arg2 = *argp2;
18071   {
18072     try {
18073       (arg1)->AddDirection(arg2);
18074     } CALL_CATCH_EXCEPTION();
18075   }
18076
18077 }
18078
18079
18080 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
18081   unsigned long jresult ;
18082   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18083   size_t result;
18084
18085   arg1 = (Dali::PanGestureDetector *)jarg1;
18086   {
18087     try {
18088       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
18089     } CALL_CATCH_EXCEPTION(0);
18090   }
18091
18092   jresult = (unsigned long)result;
18093   return jresult;
18094 }
18095
18096
18097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
18098   void * jresult ;
18099   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18100   size_t arg2 ;
18101   Dali::PanGestureDetector::AngleThresholdPair result;
18102
18103   arg1 = (Dali::PanGestureDetector *)jarg1;
18104   arg2 = (size_t)jarg2;
18105   {
18106     try {
18107       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
18108     } CALL_CATCH_EXCEPTION(0);
18109   }
18110
18111   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
18112   return jresult;
18113 }
18114
18115
18116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
18117   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18118
18119   arg1 = (Dali::PanGestureDetector *)jarg1;
18120   {
18121     try {
18122       (arg1)->ClearAngles();
18123     } CALL_CATCH_EXCEPTION();
18124   }
18125
18126 }
18127
18128
18129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
18130   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18131   Dali::Radian arg2 ;
18132   Dali::Radian *argp2 ;
18133
18134   arg1 = (Dali::PanGestureDetector *)jarg1;
18135   argp2 = (Dali::Radian *)jarg2;
18136   if (!argp2) {
18137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18138     return ;
18139   }
18140   arg2 = *argp2;
18141   {
18142     try {
18143       (arg1)->RemoveAngle(arg2);
18144     } CALL_CATCH_EXCEPTION();
18145   }
18146
18147 }
18148
18149
18150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
18151   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18152   Dali::Radian arg2 ;
18153   Dali::Radian *argp2 ;
18154
18155   arg1 = (Dali::PanGestureDetector *)jarg1;
18156   argp2 = (Dali::Radian *)jarg2;
18157   if (!argp2) {
18158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
18159     return ;
18160   }
18161   arg2 = *argp2;
18162   {
18163     try {
18164       (arg1)->RemoveDirection(arg2);
18165     } CALL_CATCH_EXCEPTION();
18166   }
18167
18168 }
18169
18170
18171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
18172   void * jresult ;
18173   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
18174   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
18175
18176   arg1 = (Dali::PanGestureDetector *)jarg1;
18177   {
18178     try {
18179       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
18180     } CALL_CATCH_EXCEPTION(0);
18181   }
18182
18183   jresult = (void *)result;
18184   return jresult;
18185 }
18186
18187
18188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
18189   Dali::PanGesture *arg1 = 0 ;
18190
18191   arg1 = (Dali::PanGesture *)jarg1;
18192   if (!arg1) {
18193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
18194     return ;
18195   }
18196   {
18197     try {
18198       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
18199     } CALL_CATCH_EXCEPTION();
18200   }
18201
18202 }
18203
18204
18205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
18206   void * jresult ;
18207   Dali::PanGesture *result = 0 ;
18208
18209   {
18210     try {
18211       result = (Dali::PanGesture *)new Dali::PanGesture();
18212     } CALL_CATCH_EXCEPTION(0);
18213   }
18214
18215   jresult = (void *)result;
18216   return jresult;
18217 }
18218
18219
18220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
18221   void * jresult ;
18222   Dali::GestureState arg1 ;
18223   Dali::PanGesture result;
18224
18225   arg1 = (Dali::GestureState)jarg1;
18226   {
18227     try {
18228       result = DevelPanGesture::New(arg1);
18229     } CALL_CATCH_EXCEPTION(0);
18230   }
18231
18232   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
18233   return jresult;
18234 }
18235
18236
18237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
18238   void * jresult ;
18239   Dali::PanGesture *arg1 = 0 ;
18240   Dali::PanGesture *result = 0 ;
18241
18242   arg1 = (Dali::PanGesture *)jarg1;
18243   if (!arg1) {
18244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
18245     return 0;
18246   }
18247   {
18248     try {
18249       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
18250     } CALL_CATCH_EXCEPTION(0);
18251   }
18252
18253   jresult = (void *)result;
18254   return jresult;
18255 }
18256
18257
18258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
18259   void * jresult ;
18260   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18261   Dali::PanGesture *arg2 = 0 ;
18262   Dali::PanGesture *result = 0 ;
18263
18264   arg1 = (Dali::PanGesture *)jarg1;
18265   arg2 = (Dali::PanGesture *)jarg2;
18266   if (!arg2) {
18267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
18268     return 0;
18269   }
18270   {
18271     try {
18272       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
18273     } CALL_CATCH_EXCEPTION(0);
18274   }
18275
18276   jresult = (void *)result;
18277   return jresult;
18278 }
18279
18280
18281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
18282   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18283
18284   arg1 = (Dali::PanGesture *)jarg1;
18285   {
18286     try {
18287       delete arg1;
18288     } CALL_CATCH_EXCEPTION();
18289   }
18290
18291 }
18292
18293
18294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
18295   void * jresult ;
18296   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18297   Dali::Vector2 result;
18298
18299   arg1 = (Dali::PanGesture *)jarg1;
18300   {
18301     try {
18302       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
18303     } catch (std::out_of_range& e) {
18304       {
18305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18306       };
18307     } catch (std::exception& e) {
18308       {
18309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18310       };
18311     } catch (Dali::DaliException e) {
18312       {
18313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18314       };
18315     } catch (...) {
18316       {
18317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18318       };
18319     }
18320   }
18321   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18322   return jresult;
18323 }
18324
18325
18326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
18327   void * jresult ;
18328   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18329   Dali::Vector2 result;
18330
18331   arg1 = (Dali::PanGesture *)jarg1;
18332   {
18333     try {
18334       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
18335     } catch (std::out_of_range& e) {
18336       {
18337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (std::exception& e) {
18340       {
18341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18342       };
18343     } catch (Dali::DaliException e) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18346       };
18347     } catch (...) {
18348       {
18349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18350       };
18351     }
18352   }
18353   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18354   return jresult;
18355 }
18356
18357
18358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
18359   void * jresult ;
18360   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18361   Dali::Vector2 result;
18362
18363   arg1 = (Dali::PanGesture *)jarg1;
18364   {
18365     try {
18366       result = ((Dali::PanGesture const *)arg1)->GetPosition();
18367     } catch (std::out_of_range& e) {
18368       {
18369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18370       };
18371     } catch (std::exception& e) {
18372       {
18373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18374       };
18375     } catch (Dali::DaliException e) {
18376       {
18377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18378       };
18379     } catch (...) {
18380       {
18381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18382       };
18383     }
18384   }
18385   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18386   return jresult;
18387 }
18388
18389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
18390   void * jresult ;
18391   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18392   Dali::Vector2 result;
18393
18394   arg1 = (Dali::PanGesture *)jarg1;
18395   {
18396     try {
18397       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
18398     } catch (std::out_of_range& e) {
18399       {
18400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18401       };
18402     } catch (std::exception& e) {
18403       {
18404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18405       };
18406     } catch (Dali::DaliException e) {
18407       {
18408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18409       };
18410     } catch (...) {
18411       {
18412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18413       };
18414     }
18415   }
18416   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18417   return jresult;
18418 }
18419
18420
18421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
18422   void * jresult ;
18423   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18424   Dali::Vector2 result;
18425
18426   arg1 = (Dali::PanGesture *)jarg1;
18427   {
18428     try {
18429       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
18430     } catch (std::out_of_range& e) {
18431       {
18432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18433       };
18434     } catch (std::exception& e) {
18435       {
18436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18437       };
18438     } catch (Dali::DaliException e) {
18439       {
18440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18441       };
18442     } catch (...) {
18443       {
18444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18445       };
18446     }
18447   }
18448   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18449   return jresult;
18450 }
18451
18452
18453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
18454   void * jresult ;
18455   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18456   Dali::Vector2 result;
18457
18458   arg1 = (Dali::PanGesture *)jarg1;
18459   {
18460     try {
18461       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
18462     } catch (std::out_of_range& e) {
18463       {
18464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18465       };
18466     } catch (std::exception& e) {
18467       {
18468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18469       };
18470     } catch (Dali::DaliException e) {
18471       {
18472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18473       };
18474     } catch (...) {
18475       {
18476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18477       };
18478     }
18479   }
18480   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18481   return jresult;
18482 }
18483
18484
18485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
18486   unsigned int jresult ;
18487   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18488   unsigned int result;
18489
18490   arg1 = (Dali::PanGesture *)jarg1;
18491   result = (unsigned int) ((arg1)->GetNumberOfTouches());
18492   jresult = result;
18493   return jresult;
18494 }
18495
18496
18497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
18498   float jresult ;
18499   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18500   float result;
18501
18502   arg1 = (Dali::PanGesture *)jarg1;
18503   {
18504     try {
18505       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
18506     } CALL_CATCH_EXCEPTION(0);
18507   }
18508
18509   jresult = result;
18510   return jresult;
18511 }
18512
18513
18514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
18515   float jresult ;
18516   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18517   float result;
18518
18519   arg1 = (Dali::PanGesture *)jarg1;
18520   {
18521     try {
18522       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
18523     } CALL_CATCH_EXCEPTION(0);
18524   }
18525
18526   jresult = result;
18527   return jresult;
18528 }
18529
18530
18531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
18532   float jresult ;
18533   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18534   float result;
18535
18536   arg1 = (Dali::PanGesture *)jarg1;
18537   {
18538     try {
18539       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
18540     } CALL_CATCH_EXCEPTION(0);
18541   }
18542
18543   jresult = result;
18544   return jresult;
18545 }
18546
18547
18548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
18549   float jresult ;
18550   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18551   float result;
18552
18553   arg1 = (Dali::PanGesture *)jarg1;
18554   {
18555     try {
18556       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
18557     } CALL_CATCH_EXCEPTION(0);
18558   }
18559
18560   jresult = result;
18561   return jresult;
18562 }
18563
18564
18565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
18566   void * jresult ;
18567   Dali::PinchGestureDetector *result = 0 ;
18568
18569   {
18570     try {
18571       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
18572     } CALL_CATCH_EXCEPTION(0);
18573   }
18574
18575   jresult = (void *)result;
18576   return jresult;
18577 }
18578
18579
18580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
18581   void * jresult ;
18582   Dali::PinchGestureDetector result;
18583
18584   {
18585     try {
18586       result = Dali::PinchGestureDetector::New();
18587     } CALL_CATCH_EXCEPTION(0);
18588   }
18589
18590   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
18591   return jresult;
18592 }
18593
18594
18595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
18596   void * jresult ;
18597   Dali::BaseHandle arg1 ;
18598   Dali::BaseHandle *argp1 ;
18599   Dali::PinchGestureDetector result;
18600
18601   argp1 = (Dali::BaseHandle *)jarg1;
18602   if (!argp1) {
18603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18604     return 0;
18605   }
18606   arg1 = *argp1;
18607   {
18608     try {
18609       result = Dali::PinchGestureDetector::DownCast(arg1);
18610     } CALL_CATCH_EXCEPTION(0);
18611   }
18612
18613   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
18614   return jresult;
18615 }
18616
18617
18618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
18619   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18620
18621   arg1 = (Dali::PinchGestureDetector *)jarg1;
18622   {
18623     try {
18624       delete arg1;
18625     } CALL_CATCH_EXCEPTION();
18626   }
18627
18628 }
18629
18630
18631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
18632   void * jresult ;
18633   Dali::PinchGestureDetector *arg1 = 0 ;
18634   Dali::PinchGestureDetector *result = 0 ;
18635
18636   arg1 = (Dali::PinchGestureDetector *)jarg1;
18637   if (!arg1) {
18638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
18639     return 0;
18640   }
18641   {
18642     try {
18643       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
18644     } CALL_CATCH_EXCEPTION(0);
18645   }
18646
18647   jresult = (void *)result;
18648   return jresult;
18649 }
18650
18651
18652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
18653   void * jresult ;
18654   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18655   Dali::PinchGestureDetector *arg2 = 0 ;
18656   Dali::PinchGestureDetector *result = 0 ;
18657
18658   arg1 = (Dali::PinchGestureDetector *)jarg1;
18659   arg2 = (Dali::PinchGestureDetector *)jarg2;
18660   if (!arg2) {
18661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
18662     return 0;
18663   }
18664   {
18665     try {
18666       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
18667     } CALL_CATCH_EXCEPTION(0);
18668   }
18669
18670   jresult = (void *)result;
18671   return jresult;
18672 }
18673
18674
18675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
18676   void * jresult ;
18677   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18678   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
18679
18680   arg1 = (Dali::PinchGestureDetector *)jarg1;
18681   {
18682     try {
18683       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
18684     } CALL_CATCH_EXCEPTION(0);
18685   }
18686
18687   jresult = (void *)result;
18688   return jresult;
18689 }
18690
18691
18692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
18693   void * jresult ;
18694   Dali::PinchGesture *result = 0 ;
18695
18696   {
18697     try {
18698       result = (Dali::PinchGesture *)new Dali::PinchGesture();
18699     } CALL_CATCH_EXCEPTION(0);
18700   }
18701
18702   jresult = (void *)result;
18703   return jresult;
18704 }
18705
18706
18707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
18708   void * jresult ;
18709   Dali::GestureState arg1 ;
18710   Dali::PinchGesture result;
18711
18712   arg1 = (Dali::GestureState)jarg1;
18713   {
18714     try {
18715       result = DevelPinchGesture::New(arg1);
18716     } CALL_CATCH_EXCEPTION(0);
18717   }
18718
18719   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
18720   return jresult;
18721 }
18722
18723
18724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
18725   void * jresult ;
18726   Dali::PinchGesture *arg1 = 0 ;
18727   Dali::PinchGesture *result = 0 ;
18728
18729   arg1 = (Dali::PinchGesture *)jarg1;
18730   if (!arg1) {
18731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
18732     return 0;
18733   }
18734   {
18735     try {
18736       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
18737     } CALL_CATCH_EXCEPTION(0);
18738   }
18739
18740   jresult = (void *)result;
18741   return jresult;
18742 }
18743
18744
18745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
18746   void * jresult ;
18747   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18748   Dali::PinchGesture *arg2 = 0 ;
18749   Dali::PinchGesture *result = 0 ;
18750
18751   arg1 = (Dali::PinchGesture *)jarg1;
18752   arg2 = (Dali::PinchGesture *)jarg2;
18753   if (!arg2) {
18754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
18755     return 0;
18756   }
18757   {
18758     try {
18759       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
18760     } CALL_CATCH_EXCEPTION(0);
18761   }
18762
18763   jresult = (void *)result;
18764   return jresult;
18765 }
18766
18767
18768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
18769   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18770
18771   arg1 = (Dali::PinchGesture *)jarg1;
18772   {
18773     try {
18774       delete arg1;
18775     } CALL_CATCH_EXCEPTION();
18776   }
18777
18778 }
18779
18780
18781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
18782   float jresult ;
18783   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18784   float result;
18785
18786   arg1 = (Dali::PinchGesture *)jarg1;
18787   result = (float) ((arg1)->GetScale());
18788   jresult = result;
18789   return jresult;
18790 }
18791
18792
18793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_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)->GetSpeed());
18800   jresult = result;
18801   return jresult;
18802 }
18803
18804
18805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
18806   void * jresult ;
18807   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18808   Dali::Vector2 result;
18809
18810   arg1 = (Dali::PinchGesture *)jarg1;
18811   {
18812     try {
18813       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
18814     } catch (std::out_of_range& e) {
18815       {
18816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (std::exception& e) {
18819       {
18820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18821       };
18822     } catch (Dali::DaliException e) {
18823       {
18824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18825       };
18826     } catch (...) {
18827       {
18828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18829       };
18830     }
18831   }
18832   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18833   return jresult;
18834 }
18835
18836
18837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
18838   void * jresult ;
18839   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18840   Dali::Vector2 result;
18841
18842   arg1 = (Dali::PinchGesture *)jarg1;
18843   {
18844     try {
18845       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
18846     } catch (std::out_of_range& e) {
18847       {
18848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18849       };
18850     } catch (std::exception& e) {
18851       {
18852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18853       };
18854     } catch (Dali::DaliException e) {
18855       {
18856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18857       };
18858     } catch (...) {
18859       {
18860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18861       };
18862     }
18863   }
18864   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18865   return jresult;
18866 }
18867
18868
18869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
18870   void * jresult ;
18871   Dali::TapGestureDetector *result = 0 ;
18872
18873   {
18874     try {
18875       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
18876     } CALL_CATCH_EXCEPTION(0);
18877   }
18878
18879   jresult = (void *)result;
18880   return jresult;
18881 }
18882
18883
18884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
18885   void * jresult ;
18886   Dali::TapGestureDetector result;
18887
18888   {
18889     try {
18890       result = Dali::TapGestureDetector::New();
18891     } CALL_CATCH_EXCEPTION(0);
18892   }
18893
18894   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18895   return jresult;
18896 }
18897
18898
18899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
18900   void * jresult ;
18901   unsigned int arg1 ;
18902   Dali::TapGestureDetector result;
18903
18904   arg1 = (unsigned int)jarg1;
18905   {
18906     try {
18907       result = Dali::TapGestureDetector::New(arg1);
18908     } CALL_CATCH_EXCEPTION(0);
18909   }
18910
18911   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18912   return jresult;
18913 }
18914
18915
18916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
18917   void * jresult ;
18918   Dali::BaseHandle arg1 ;
18919   Dali::BaseHandle *argp1 ;
18920   Dali::TapGestureDetector result;
18921
18922   argp1 = (Dali::BaseHandle *)jarg1;
18923   if (!argp1) {
18924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18925     return 0;
18926   }
18927   arg1 = *argp1;
18928   {
18929     try {
18930       result = Dali::TapGestureDetector::DownCast(arg1);
18931     } CALL_CATCH_EXCEPTION(0);
18932   }
18933
18934   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18935   return jresult;
18936 }
18937
18938
18939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
18940   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18941
18942   arg1 = (Dali::TapGestureDetector *)jarg1;
18943   {
18944     try {
18945       delete arg1;
18946     } CALL_CATCH_EXCEPTION();
18947   }
18948
18949 }
18950
18951
18952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
18953   void * jresult ;
18954   Dali::TapGestureDetector *arg1 = 0 ;
18955   Dali::TapGestureDetector *result = 0 ;
18956
18957   arg1 = (Dali::TapGestureDetector *)jarg1;
18958   if (!arg1) {
18959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18960     return 0;
18961   }
18962   {
18963     try {
18964       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
18965     } CALL_CATCH_EXCEPTION(0);
18966   }
18967
18968   jresult = (void *)result;
18969   return jresult;
18970 }
18971
18972
18973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
18974   void * jresult ;
18975   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18976   Dali::TapGestureDetector *arg2 = 0 ;
18977   Dali::TapGestureDetector *result = 0 ;
18978
18979   arg1 = (Dali::TapGestureDetector *)jarg1;
18980   arg2 = (Dali::TapGestureDetector *)jarg2;
18981   if (!arg2) {
18982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18983     return 0;
18984   }
18985   {
18986     try {
18987       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
18988     } CALL_CATCH_EXCEPTION(0);
18989   }
18990
18991   jresult = (void *)result;
18992   return jresult;
18993 }
18994
18995
18996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
18997   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18998   unsigned int arg2 ;
18999
19000   arg1 = (Dali::TapGestureDetector *)jarg1;
19001   arg2 = (unsigned int)jarg2;
19002   {
19003     try {
19004       (arg1)->SetMinimumTapsRequired(arg2);
19005     } CALL_CATCH_EXCEPTION();
19006   }
19007
19008 }
19009
19010
19011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
19012   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19013   unsigned int arg2 ;
19014
19015   arg1 = (Dali::TapGestureDetector *)jarg1;
19016   arg2 = (unsigned int)jarg2;
19017   {
19018     try {
19019       (arg1)->SetMaximumTapsRequired(arg2);
19020     } CALL_CATCH_EXCEPTION();
19021   }
19022
19023 }
19024
19025
19026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
19027   unsigned int jresult ;
19028   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19029   unsigned int result;
19030
19031   arg1 = (Dali::TapGestureDetector *)jarg1;
19032   {
19033     try {
19034       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
19035     } CALL_CATCH_EXCEPTION(0);
19036   }
19037
19038   jresult = result;
19039   return jresult;
19040 }
19041
19042
19043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
19044   unsigned int jresult ;
19045   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19046   unsigned int result;
19047
19048   arg1 = (Dali::TapGestureDetector *)jarg1;
19049   {
19050     try {
19051       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
19052     } CALL_CATCH_EXCEPTION(0);
19053   }
19054
19055   jresult = result;
19056   return jresult;
19057 }
19058
19059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
19060   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
19061
19062   detector = (Dali::TapGestureDetector *)tapGestureDetector;
19063   if (!detector) {
19064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
19065     return;
19066   }
19067   {
19068     try {
19069       (detector)->ReceiveAllTapEvents(isReceive);
19070     } CALL_CATCH_EXCEPTION();
19071   }
19072
19073 }
19074
19075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
19076   void * jresult ;
19077   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
19078   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
19079
19080   arg1 = (Dali::TapGestureDetector *)jarg1;
19081   {
19082     try {
19083       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
19084     } CALL_CATCH_EXCEPTION(0);
19085   }
19086
19087   jresult = (void *)result;
19088   return jresult;
19089 }
19090
19091
19092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
19093   void * jresult ;
19094   Dali::TapGesture *result = 0 ;
19095
19096   {
19097     try {
19098       result = (Dali::TapGesture *)new Dali::TapGesture();
19099     } CALL_CATCH_EXCEPTION(0);
19100   }
19101
19102   jresult = (void *)result;
19103   return jresult;
19104 }
19105
19106
19107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
19108   void * jresult ;
19109   Dali::GestureState arg1 ;
19110   Dali::TapGesture result;
19111
19112   arg1 = (Dali::GestureState)jarg1;
19113   {
19114     try {
19115       result = DevelTapGesture::New(arg1);
19116     } CALL_CATCH_EXCEPTION(0);
19117   }
19118
19119   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
19120   return jresult;
19121 }
19122
19123
19124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
19125   void * jresult ;
19126   Dali::TapGesture *arg1 = 0 ;
19127   Dali::TapGesture *result = 0 ;
19128
19129   arg1 = (Dali::TapGesture *)jarg1;
19130   if (!arg1) {
19131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
19132     return 0;
19133   }
19134   {
19135     try {
19136       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
19137     } CALL_CATCH_EXCEPTION(0);
19138   }
19139
19140   jresult = (void *)result;
19141   return jresult;
19142 }
19143
19144
19145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
19146   void * jresult ;
19147   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19148   Dali::TapGesture *arg2 = 0 ;
19149   Dali::TapGesture *result = 0 ;
19150
19151   arg1 = (Dali::TapGesture *)jarg1;
19152   arg2 = (Dali::TapGesture *)jarg2;
19153   if (!arg2) {
19154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
19155     return 0;
19156   }
19157   {
19158     try {
19159       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
19160     } CALL_CATCH_EXCEPTION(0);
19161   }
19162
19163   jresult = (void *)result;
19164   return jresult;
19165 }
19166
19167
19168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
19169   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19170
19171   arg1 = (Dali::TapGesture *)jarg1;
19172   {
19173     try {
19174       delete arg1;
19175     } CALL_CATCH_EXCEPTION();
19176   }
19177
19178 }
19179
19180
19181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
19182   unsigned int jresult ;
19183   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19184   unsigned int result;
19185
19186   arg1 = (Dali::TapGesture *)jarg1;
19187   result = (unsigned int) ((arg1)->GetNumberOfTaps());
19188   jresult = result;
19189   return jresult;
19190 }
19191
19192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
19193   unsigned int jresult ;
19194   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19195   unsigned int result;
19196
19197   arg1 = (Dali::TapGesture *)jarg1;
19198   result = (unsigned int) ((arg1)->GetNumberOfTouches());
19199   jresult = result;
19200   return jresult;
19201 }
19202
19203
19204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
19205   void * jresult ;
19206   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19207   Dali::Vector2 result;
19208
19209   arg1 = (Dali::TapGesture *)jarg1;
19210   {
19211     try {
19212       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
19213     } catch (std::out_of_range& e) {
19214       {
19215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19216       };
19217     } catch (std::exception& e) {
19218       {
19219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19220       };
19221     } catch (Dali::DaliException e) {
19222       {
19223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19224       };
19225     } catch (...) {
19226       {
19227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19228       };
19229     }
19230   }
19231   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19232   return jresult;
19233 }
19234
19235
19236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
19237   void * jresult ;
19238   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
19239   Dali::Vector2 result;
19240
19241   arg1 = (Dali::TapGesture *)jarg1;
19242   {
19243     try {
19244       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
19245     } catch (std::out_of_range& e) {
19246       {
19247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19248       };
19249     } catch (std::exception& e) {
19250       {
19251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19252       };
19253     } catch (Dali::DaliException e) {
19254       {
19255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19256       };
19257     } catch (...) {
19258       {
19259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19260       };
19261     }
19262   }
19263   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
19264   return jresult;
19265 }
19266
19267
19268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
19269   void * jresult ;
19270   Dali::AlphaFunction *result = 0 ;
19271
19272   {
19273     try {
19274       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
19275     } CALL_CATCH_EXCEPTION(0);
19276   }
19277
19278   jresult = (void *)result;
19279   return jresult;
19280 }
19281
19282
19283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
19284   void * jresult ;
19285   Dali::AlphaFunction::BuiltinFunction arg1 ;
19286   Dali::AlphaFunction *result = 0 ;
19287
19288   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
19289   {
19290     try {
19291       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
19292     } CALL_CATCH_EXCEPTION(0);
19293   }
19294
19295   jresult = (void *)result;
19296   return jresult;
19297 }
19298
19299
19300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
19301   void * jresult ;
19302   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
19303   Dali::AlphaFunction *result = 0 ;
19304
19305   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
19306   {
19307     try {
19308       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
19309     } CALL_CATCH_EXCEPTION(0);
19310   }
19311
19312   jresult = (void *)result;
19313   return jresult;
19314 }
19315
19316
19317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
19318   void * jresult ;
19319   Dali::Vector2 *arg1 = 0 ;
19320   Dali::Vector2 *arg2 = 0 ;
19321   Dali::AlphaFunction *result = 0 ;
19322
19323   arg1 = (Dali::Vector2 *)jarg1;
19324   if (!arg1) {
19325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19326     return 0;
19327   }
19328   arg2 = (Dali::Vector2 *)jarg2;
19329   if (!arg2) {
19330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19331     return 0;
19332   }
19333   {
19334     try {
19335       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
19336     } CALL_CATCH_EXCEPTION(0);
19337   }
19338
19339   jresult = (void *)result;
19340   return jresult;
19341 }
19342
19343
19344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
19345   void * jresult ;
19346   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19347   Dali::Vector4 result;
19348
19349   arg1 = (Dali::AlphaFunction *)jarg1;
19350   {
19351     try {
19352       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
19353     } CALL_CATCH_EXCEPTION(0);
19354   }
19355
19356   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
19357   return jresult;
19358 }
19359
19360
19361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
19362   void * jresult ;
19363   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19364   Dali::AlphaFunctionPrototype result;
19365
19366   arg1 = (Dali::AlphaFunction *)jarg1;
19367   {
19368     try {
19369       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
19370     } CALL_CATCH_EXCEPTION(0);
19371   }
19372
19373   jresult = (void *)result;
19374   return jresult;
19375 }
19376
19377
19378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
19379   int jresult ;
19380   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19381   Dali::AlphaFunction::BuiltinFunction result;
19382
19383   arg1 = (Dali::AlphaFunction *)jarg1;
19384   {
19385     try {
19386       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
19387     } CALL_CATCH_EXCEPTION(0);
19388   }
19389
19390   jresult = (int)result;
19391   return jresult;
19392 }
19393
19394
19395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
19396   int jresult ;
19397   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19398   Dali::AlphaFunction::Mode result;
19399
19400   arg1 = (Dali::AlphaFunction *)jarg1;
19401   {
19402     try {
19403       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
19404     } CALL_CATCH_EXCEPTION(0);
19405   }
19406
19407   jresult = (int)result;
19408   return jresult;
19409 }
19410
19411
19412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
19413   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19414
19415   arg1 = (Dali::AlphaFunction *)jarg1;
19416   {
19417     try {
19418       delete arg1;
19419     } CALL_CATCH_EXCEPTION();
19420   }
19421
19422 }
19423
19424
19425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
19426   void * jresult ;
19427   Dali::KeyFrames result;
19428
19429   {
19430     try {
19431       result = Dali::KeyFrames::New();
19432     } CALL_CATCH_EXCEPTION(0);
19433   }
19434
19435   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
19441   void * jresult ;
19442   Dali::BaseHandle arg1 ;
19443   Dali::BaseHandle *argp1 ;
19444   Dali::KeyFrames result;
19445
19446   argp1 = (Dali::BaseHandle *)jarg1;
19447   if (!argp1) {
19448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19449     return 0;
19450   }
19451   arg1 = *argp1;
19452   {
19453     try {
19454       result = Dali::KeyFrames::DownCast(arg1);
19455     } CALL_CATCH_EXCEPTION(0);
19456   }
19457
19458   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
19459   return jresult;
19460 }
19461
19462
19463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
19464   void * jresult ;
19465   Dali::KeyFrames *result = 0 ;
19466
19467   {
19468     try {
19469       result = (Dali::KeyFrames *)new Dali::KeyFrames();
19470     } CALL_CATCH_EXCEPTION(0);
19471   }
19472
19473   jresult = (void *)result;
19474   return jresult;
19475 }
19476
19477
19478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
19479   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19480
19481   arg1 = (Dali::KeyFrames *)jarg1;
19482   {
19483     try {
19484       delete arg1;
19485     } CALL_CATCH_EXCEPTION();
19486   }
19487
19488 }
19489
19490
19491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
19492   void * jresult ;
19493   Dali::KeyFrames *arg1 = 0 ;
19494   Dali::KeyFrames *result = 0 ;
19495
19496   arg1 = (Dali::KeyFrames *)jarg1;
19497   if (!arg1) {
19498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
19499     return 0;
19500   }
19501   {
19502     try {
19503       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
19504     } CALL_CATCH_EXCEPTION(0);
19505   }
19506
19507   jresult = (void *)result;
19508   return jresult;
19509 }
19510
19511
19512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
19513   void * jresult ;
19514   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19515   Dali::KeyFrames *arg2 = 0 ;
19516   Dali::KeyFrames *result = 0 ;
19517
19518   arg1 = (Dali::KeyFrames *)jarg1;
19519   arg2 = (Dali::KeyFrames *)jarg2;
19520   if (!arg2) {
19521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
19522     return 0;
19523   }
19524   {
19525     try {
19526       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
19527     } CALL_CATCH_EXCEPTION(0);
19528   }
19529
19530   jresult = (void *)result;
19531   return jresult;
19532 }
19533
19534
19535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
19536   int jresult ;
19537   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19538   Dali::Property::Type result;
19539
19540   arg1 = (Dali::KeyFrames *)jarg1;
19541   {
19542     try {
19543       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
19544     } CALL_CATCH_EXCEPTION(0);
19545   }
19546
19547   jresult = (int)result;
19548   return jresult;
19549 }
19550
19551
19552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
19553   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19554   float arg2 ;
19555   Dali::Property::Value arg3 ;
19556   Dali::Property::Value *argp3 ;
19557
19558   arg1 = (Dali::KeyFrames *)jarg1;
19559   arg2 = (float)jarg2;
19560   argp3 = (Dali::Property::Value *)jarg3;
19561   if (!argp3) {
19562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19563     return ;
19564   }
19565   arg3 = *argp3;
19566   {
19567     try {
19568       (arg1)->Add(arg2,arg3);
19569     } CALL_CATCH_EXCEPTION();
19570   }
19571
19572 }
19573
19574
19575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
19576   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19577   float arg2 ;
19578   Dali::Property::Value arg3 ;
19579   Dali::AlphaFunction arg4 ;
19580   Dali::Property::Value *argp3 ;
19581   Dali::AlphaFunction *argp4 ;
19582
19583   arg1 = (Dali::KeyFrames *)jarg1;
19584   arg2 = (float)jarg2;
19585   argp3 = (Dali::Property::Value *)jarg3;
19586   if (!argp3) {
19587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19588     return ;
19589   }
19590   arg3 = *argp3;
19591   argp4 = (Dali::AlphaFunction *)jarg4;
19592   if (!argp4) {
19593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
19594     return ;
19595   }
19596   arg4 = *argp4;
19597   {
19598     try {
19599       (arg1)->Add(arg2,arg3,arg4);
19600     } CALL_CATCH_EXCEPTION();
19601   }
19602
19603 }
19604
19605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
19606 {
19607   unsigned int jresult;
19608   {
19609     try {
19610       jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
19611     } CALL_CATCH_EXCEPTION(0);
19612   }
19613   return jresult;
19614 }
19615
19616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
19617 {
19618   if (!value) {
19619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19620     return ;
19621   }
19622   try {
19623     Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
19624   } CALL_CATCH_EXCEPTION();
19625 }
19626
19627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value)
19628 {
19629   if (!value) {
19630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19631     return ;
19632   }
19633   try {
19634     Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value));
19635   } CALL_CATCH_EXCEPTION();
19636 }
19637
19638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
19639   int jresult ;
19640   int result;
19641
19642   result = (int)Dali::Path::Property::POINTS;
19643   jresult = (int)result;
19644   return jresult;
19645 }
19646
19647
19648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
19649   int jresult ;
19650   int result;
19651
19652   result = (int)Dali::Path::Property::CONTROL_POINTS;
19653   jresult = (int)result;
19654   return jresult;
19655 }
19656
19657
19658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
19659   void * jresult ;
19660   Dali::Path::Property *result = 0 ;
19661
19662   {
19663     try {
19664       result = (Dali::Path::Property *)new Dali::Path::Property();
19665     } CALL_CATCH_EXCEPTION(0);
19666   }
19667
19668   jresult = (void *)result;
19669   return jresult;
19670 }
19671
19672
19673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
19674   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
19675
19676   arg1 = (Dali::Path::Property *)jarg1;
19677   {
19678     try {
19679       delete arg1;
19680     } CALL_CATCH_EXCEPTION();
19681   }
19682
19683 }
19684
19685
19686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
19687   void * jresult ;
19688   Dali::Path result;
19689
19690   {
19691     try {
19692       result = Dali::Path::New();
19693     } CALL_CATCH_EXCEPTION(0);
19694   }
19695
19696   jresult = new Dali::Path((const Dali::Path &)result);
19697   return jresult;
19698 }
19699
19700
19701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
19702   void * jresult ;
19703   Dali::BaseHandle arg1 ;
19704   Dali::BaseHandle *argp1 ;
19705   Dali::Path result;
19706
19707   argp1 = (Dali::BaseHandle *)jarg1;
19708   if (!argp1) {
19709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19710     return 0;
19711   }
19712   arg1 = *argp1;
19713   {
19714     try {
19715       result = Dali::Path::DownCast(arg1);
19716     } CALL_CATCH_EXCEPTION(0);
19717   }
19718
19719   jresult = new Dali::Path((const Dali::Path &)result);
19720   return jresult;
19721 }
19722
19723
19724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
19725   void * jresult ;
19726   Dali::Path *result = 0 ;
19727
19728   {
19729     try {
19730       result = (Dali::Path *)new Dali::Path();
19731     } CALL_CATCH_EXCEPTION(0);
19732   }
19733
19734   jresult = (void *)result;
19735   return jresult;
19736 }
19737
19738
19739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
19740   Dali::Path *arg1 = (Dali::Path *) 0 ;
19741
19742   arg1 = (Dali::Path *)jarg1;
19743   {
19744     try {
19745       delete arg1;
19746     } CALL_CATCH_EXCEPTION();
19747   }
19748
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
19753   void * jresult ;
19754   Dali::Path *arg1 = 0 ;
19755   Dali::Path *result = 0 ;
19756
19757   arg1 = (Dali::Path *)jarg1;
19758   if (!arg1) {
19759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
19760     return 0;
19761   }
19762   {
19763     try {
19764       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
19765     } CALL_CATCH_EXCEPTION(0);
19766   }
19767
19768   jresult = (void *)result;
19769   return jresult;
19770 }
19771
19772
19773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
19774   void * jresult ;
19775   Dali::Path *arg1 = (Dali::Path *) 0 ;
19776   Dali::Path *arg2 = 0 ;
19777   Dali::Path *result = 0 ;
19778
19779   arg1 = (Dali::Path *)jarg1;
19780   arg2 = (Dali::Path *)jarg2;
19781   if (!arg2) {
19782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
19783     return 0;
19784   }
19785   {
19786     try {
19787       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
19788     } CALL_CATCH_EXCEPTION(0);
19789   }
19790
19791   jresult = (void *)result;
19792   return jresult;
19793 }
19794
19795
19796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
19797   Dali::Path *arg1 = (Dali::Path *) 0 ;
19798   Dali::Vector3 *arg2 = 0 ;
19799
19800   arg1 = (Dali::Path *)jarg1;
19801   arg2 = (Dali::Vector3 *)jarg2;
19802   if (!arg2) {
19803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19804     return ;
19805   }
19806   {
19807     try {
19808       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
19809     } CALL_CATCH_EXCEPTION();
19810   }
19811
19812 }
19813
19814
19815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
19816   Dali::Path *arg1 = (Dali::Path *) 0 ;
19817   Dali::Vector3 *arg2 = 0 ;
19818
19819   arg1 = (Dali::Path *)jarg1;
19820   arg2 = (Dali::Vector3 *)jarg2;
19821   if (!arg2) {
19822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19823     return ;
19824   }
19825   {
19826     try {
19827       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
19828     } CALL_CATCH_EXCEPTION();
19829   }
19830
19831 }
19832
19833
19834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
19835   Dali::Path *arg1 = (Dali::Path *) 0 ;
19836   float arg2 ;
19837
19838   arg1 = (Dali::Path *)jarg1;
19839   arg2 = (float)jarg2;
19840   {
19841     try {
19842       (arg1)->GenerateControlPoints(arg2);
19843     } CALL_CATCH_EXCEPTION();
19844   }
19845
19846 }
19847
19848
19849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
19850   Dali::Path *arg1 = (Dali::Path *) 0 ;
19851   float arg2 ;
19852   Dali::Vector3 *arg3 = 0 ;
19853   Dali::Vector3 *arg4 = 0 ;
19854
19855   arg1 = (Dali::Path *)jarg1;
19856   arg2 = (float)jarg2;
19857   arg3 = (Dali::Vector3 *)jarg3;
19858   if (!arg3) {
19859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
19860     return ;
19861   }
19862   arg4 = (Dali::Vector3 *)jarg4;
19863   if (!arg4) {
19864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
19865     return ;
19866   }
19867   {
19868     try {
19869       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
19870     } CALL_CATCH_EXCEPTION();
19871   }
19872
19873 }
19874
19875
19876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
19877   void * jresult ;
19878   Dali::Path *arg1 = (Dali::Path *) 0 ;
19879   size_t arg2 ;
19880   Dali::Vector3 *result = 0 ;
19881
19882   arg1 = (Dali::Path *)jarg1;
19883   arg2 = (size_t)jarg2;
19884   {
19885     try {
19886       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
19887     } CALL_CATCH_EXCEPTION(0);
19888   }
19889
19890   jresult = (void *)result;
19891   return jresult;
19892 }
19893
19894
19895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
19896   void * jresult ;
19897   Dali::Path *arg1 = (Dali::Path *) 0 ;
19898   size_t arg2 ;
19899   Dali::Vector3 *result = 0 ;
19900
19901   arg1 = (Dali::Path *)jarg1;
19902   arg2 = (size_t)jarg2;
19903   {
19904     try {
19905       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
19906     } CALL_CATCH_EXCEPTION(0);
19907   }
19908
19909   jresult = (void *)result;
19910   return jresult;
19911 }
19912
19913
19914 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
19915   unsigned long jresult ;
19916   Dali::Path *arg1 = (Dali::Path *) 0 ;
19917   size_t result;
19918
19919   arg1 = (Dali::Path *)jarg1;
19920   {
19921     try {
19922       result = ((Dali::Path const *)arg1)->GetPointCount();
19923     } CALL_CATCH_EXCEPTION(0);
19924   }
19925
19926   jresult = (unsigned long)result;
19927   return jresult;
19928 }
19929
19930
19931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
19932   void * jresult ;
19933   float arg1 ;
19934   Dali::TimePeriod *result = 0 ;
19935
19936   arg1 = (float)jarg1;
19937   {
19938     try {
19939       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
19940     } CALL_CATCH_EXCEPTION(0);
19941   }
19942
19943   jresult = (void *)result;
19944   return jresult;
19945 }
19946
19947
19948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
19949   void * jresult ;
19950   float arg1 ;
19951   float arg2 ;
19952   Dali::TimePeriod *result = 0 ;
19953
19954   arg1 = (float)jarg1;
19955   arg2 = (float)jarg2;
19956   {
19957     try {
19958       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
19959     } CALL_CATCH_EXCEPTION(0);
19960   }
19961
19962   jresult = (void *)result;
19963   return jresult;
19964 }
19965
19966
19967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
19968   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19969
19970   arg1 = (Dali::TimePeriod *)jarg1;
19971   {
19972     try {
19973       delete arg1;
19974     } CALL_CATCH_EXCEPTION();
19975   }
19976
19977 }
19978
19979
19980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
19981   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19982   float arg2 ;
19983
19984   arg1 = (Dali::TimePeriod *)jarg1;
19985   arg2 = (float)jarg2;
19986   if (arg1) (arg1)->delaySeconds = arg2;
19987 }
19988
19989
19990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
19991   float jresult ;
19992   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19993   float result;
19994
19995   arg1 = (Dali::TimePeriod *)jarg1;
19996   result = (float) ((arg1)->delaySeconds);
19997   jresult = result;
19998   return jresult;
19999 }
20000
20001
20002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
20003   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
20004   float arg2 ;
20005
20006   arg1 = (Dali::TimePeriod *)jarg1;
20007   arg2 = (float)jarg2;
20008   if (arg1) (arg1)->durationSeconds = arg2;
20009 }
20010
20011
20012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
20013   float jresult ;
20014   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
20015   float result;
20016
20017   arg1 = (Dali::TimePeriod *)jarg1;
20018   result = (float) ((arg1)->durationSeconds);
20019   jresult = result;
20020   return jresult;
20021 }
20022
20023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
20024   int jresult ;
20025   int result;
20026
20027   result = (int)Dali::LinearConstrainer::Property::VALUE;
20028   jresult = (int)result;
20029   return jresult;
20030 }
20031
20032
20033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
20034   int jresult ;
20035   int result;
20036
20037   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
20038   jresult = (int)result;
20039   return jresult;
20040 }
20041
20042
20043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
20044   void * jresult ;
20045   Dali::LinearConstrainer::Property *result = 0 ;
20046
20047   {
20048     try {
20049       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
20050     } CALL_CATCH_EXCEPTION(0);
20051   }
20052
20053   jresult = (void *)result;
20054   return jresult;
20055 }
20056
20057
20058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
20059   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
20060
20061   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
20062   {
20063     try {
20064       delete arg1;
20065     } CALL_CATCH_EXCEPTION();
20066   }
20067
20068 }
20069
20070
20071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
20072   void * jresult ;
20073   Dali::LinearConstrainer result;
20074
20075   {
20076     try {
20077       result = Dali::LinearConstrainer::New();
20078     } CALL_CATCH_EXCEPTION(0);
20079   }
20080
20081   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
20082   return jresult;
20083 }
20084
20085
20086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
20087   void * jresult ;
20088   Dali::BaseHandle arg1 ;
20089   Dali::BaseHandle *argp1 ;
20090   Dali::LinearConstrainer result;
20091
20092   argp1 = (Dali::BaseHandle *)jarg1;
20093   if (!argp1) {
20094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20095     return 0;
20096   }
20097   arg1 = *argp1;
20098   {
20099     try {
20100       result = Dali::LinearConstrainer::DownCast(arg1);
20101     } CALL_CATCH_EXCEPTION(0);
20102   }
20103
20104   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
20105   return jresult;
20106 }
20107
20108
20109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
20110   void * jresult ;
20111   Dali::LinearConstrainer *result = 0 ;
20112
20113   {
20114     try {
20115       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
20116     } CALL_CATCH_EXCEPTION(0);
20117   }
20118
20119   jresult = (void *)result;
20120   return jresult;
20121 }
20122
20123
20124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
20125   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20126
20127   arg1 = (Dali::LinearConstrainer *)jarg1;
20128   {
20129     try {
20130       delete arg1;
20131     } CALL_CATCH_EXCEPTION();
20132   }
20133
20134 }
20135
20136
20137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
20138   void * jresult ;
20139   Dali::LinearConstrainer *arg1 = 0 ;
20140   Dali::LinearConstrainer *result = 0 ;
20141
20142   arg1 = (Dali::LinearConstrainer *)jarg1;
20143   if (!arg1) {
20144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
20145     return 0;
20146   }
20147   {
20148     try {
20149       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
20150     } CALL_CATCH_EXCEPTION(0);
20151   }
20152
20153   jresult = (void *)result;
20154   return jresult;
20155 }
20156
20157
20158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
20159   void * jresult ;
20160   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20161   Dali::LinearConstrainer *arg2 = 0 ;
20162   Dali::LinearConstrainer *result = 0 ;
20163
20164   arg1 = (Dali::LinearConstrainer *)jarg1;
20165   arg2 = (Dali::LinearConstrainer *)jarg2;
20166   if (!arg2) {
20167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
20168     return 0;
20169   }
20170   {
20171     try {
20172       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
20173     } CALL_CATCH_EXCEPTION(0);
20174   }
20175
20176   jresult = (void *)result;
20177   return jresult;
20178 }
20179
20180
20181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
20182   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20183   SwigValueWrapper< Dali::Property > arg2 ;
20184   SwigValueWrapper< Dali::Property > arg3 ;
20185   Dali::Vector2 *arg4 = 0 ;
20186   Dali::Vector2 *arg5 = 0 ;
20187   Dali::Property *argp2 ;
20188   Dali::Property *argp3 ;
20189
20190   arg1 = (Dali::LinearConstrainer *)jarg1;
20191   argp2 = (Dali::Property *)jarg2;
20192   if (!argp2) {
20193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20194     return ;
20195   }
20196   arg2 = *argp2;
20197   argp3 = (Dali::Property *)jarg3;
20198   if (!argp3) {
20199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20200     return ;
20201   }
20202   arg3 = *argp3;
20203   arg4 = (Dali::Vector2 *)jarg4;
20204   if (!arg4) {
20205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20206     return ;
20207   }
20208   arg5 = (Dali::Vector2 *)jarg5;
20209   if (!arg5) {
20210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20211     return ;
20212   }
20213   {
20214     try {
20215       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
20216     } CALL_CATCH_EXCEPTION();
20217   }
20218
20219 }
20220
20221
20222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
20223   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20224   SwigValueWrapper< Dali::Property > arg2 ;
20225   SwigValueWrapper< Dali::Property > arg3 ;
20226   Dali::Vector2 *arg4 = 0 ;
20227   Dali::Property *argp2 ;
20228   Dali::Property *argp3 ;
20229
20230   arg1 = (Dali::LinearConstrainer *)jarg1;
20231   argp2 = (Dali::Property *)jarg2;
20232   if (!argp2) {
20233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20234     return ;
20235   }
20236   arg2 = *argp2;
20237   argp3 = (Dali::Property *)jarg3;
20238   if (!argp3) {
20239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20240     return ;
20241   }
20242   arg3 = *argp3;
20243   arg4 = (Dali::Vector2 *)jarg4;
20244   if (!arg4) {
20245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20246     return ;
20247   }
20248   {
20249     try {
20250       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
20251     } CALL_CATCH_EXCEPTION();
20252   }
20253
20254 }
20255
20256
20257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
20258   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
20259   Dali::Handle *arg2 = 0 ;
20260
20261   arg1 = (Dali::LinearConstrainer *)jarg1;
20262   arg2 = (Dali::Handle *)jarg2;
20263   if (!arg2) {
20264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
20265     return ;
20266   }
20267   {
20268     try {
20269       (arg1)->Remove(*arg2);
20270     } CALL_CATCH_EXCEPTION();
20271   }
20272
20273 }
20274
20275
20276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
20277   int jresult ;
20278   int result;
20279
20280   result = (int)Dali::PathConstrainer::Property::FORWARD;
20281   jresult = (int)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
20287   int jresult ;
20288   int result;
20289
20290   result = (int)Dali::PathConstrainer::Property::POINTS;
20291   jresult = (int)result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
20297   int jresult ;
20298   int result;
20299
20300   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
20301   jresult = (int)result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
20307   void * jresult ;
20308   Dali::PathConstrainer::Property *result = 0 ;
20309
20310   {
20311     try {
20312       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
20313     } CALL_CATCH_EXCEPTION(0);
20314   }
20315
20316   jresult = (void *)result;
20317   return jresult;
20318 }
20319
20320
20321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
20322   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
20323
20324   arg1 = (Dali::PathConstrainer::Property *)jarg1;
20325   {
20326     try {
20327       delete arg1;
20328     } CALL_CATCH_EXCEPTION();
20329   }
20330
20331 }
20332
20333
20334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
20335   void * jresult ;
20336   Dali::PathConstrainer result;
20337
20338   {
20339     try {
20340       result = Dali::PathConstrainer::New();
20341     } CALL_CATCH_EXCEPTION(0);
20342   }
20343
20344   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
20345   return jresult;
20346 }
20347
20348
20349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
20350   void * jresult ;
20351   Dali::BaseHandle arg1 ;
20352   Dali::BaseHandle *argp1 ;
20353   Dali::PathConstrainer result;
20354
20355   argp1 = (Dali::BaseHandle *)jarg1;
20356   if (!argp1) {
20357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20358     return 0;
20359   }
20360   arg1 = *argp1;
20361   {
20362     try {
20363       result = Dali::PathConstrainer::DownCast(arg1);
20364     } CALL_CATCH_EXCEPTION(0);
20365   }
20366
20367   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
20368   return jresult;
20369 }
20370
20371
20372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
20373   void * jresult ;
20374   Dali::PathConstrainer *result = 0 ;
20375
20376   {
20377     try {
20378       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
20379     } CALL_CATCH_EXCEPTION(0);
20380   }
20381
20382   jresult = (void *)result;
20383   return jresult;
20384 }
20385
20386
20387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
20388   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20389
20390   arg1 = (Dali::PathConstrainer *)jarg1;
20391   {
20392     try {
20393       delete arg1;
20394     } CALL_CATCH_EXCEPTION();
20395   }
20396
20397 }
20398
20399
20400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
20401   void * jresult ;
20402   Dali::PathConstrainer *arg1 = 0 ;
20403   Dali::PathConstrainer *result = 0 ;
20404
20405   arg1 = (Dali::PathConstrainer *)jarg1;
20406   if (!arg1) {
20407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
20408     return 0;
20409   }
20410   {
20411     try {
20412       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
20413     } CALL_CATCH_EXCEPTION(0);
20414   }
20415
20416   jresult = (void *)result;
20417   return jresult;
20418 }
20419
20420
20421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
20422   void * jresult ;
20423   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20424   Dali::PathConstrainer *arg2 = 0 ;
20425   Dali::PathConstrainer *result = 0 ;
20426
20427   arg1 = (Dali::PathConstrainer *)jarg1;
20428   arg2 = (Dali::PathConstrainer *)jarg2;
20429   if (!arg2) {
20430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
20431     return 0;
20432   }
20433   {
20434     try {
20435       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
20436     } CALL_CATCH_EXCEPTION(0);
20437   }
20438
20439   jresult = (void *)result;
20440   return jresult;
20441 }
20442
20443
20444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
20445   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20446   SwigValueWrapper< Dali::Property > arg2 ;
20447   SwigValueWrapper< Dali::Property > arg3 ;
20448   Dali::Vector2 *arg4 = 0 ;
20449   Dali::Vector2 *arg5 = 0 ;
20450   Dali::Property *argp2 ;
20451   Dali::Property *argp3 ;
20452
20453   arg1 = (Dali::PathConstrainer *)jarg1;
20454   argp2 = (Dali::Property *)jarg2;
20455   if (!argp2) {
20456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20457     return ;
20458   }
20459   arg2 = *argp2;
20460   argp3 = (Dali::Property *)jarg3;
20461   if (!argp3) {
20462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20463     return ;
20464   }
20465   arg3 = *argp3;
20466   arg4 = (Dali::Vector2 *)jarg4;
20467   if (!arg4) {
20468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20469     return ;
20470   }
20471   arg5 = (Dali::Vector2 *)jarg5;
20472   if (!arg5) {
20473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20474     return ;
20475   }
20476   {
20477     try {
20478       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
20479     } CALL_CATCH_EXCEPTION();
20480   }
20481
20482 }
20483
20484
20485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
20486   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20487   SwigValueWrapper< Dali::Property > arg2 ;
20488   SwigValueWrapper< Dali::Property > arg3 ;
20489   Dali::Vector2 *arg4 = 0 ;
20490   Dali::Property *argp2 ;
20491   Dali::Property *argp3 ;
20492
20493   arg1 = (Dali::PathConstrainer *)jarg1;
20494   argp2 = (Dali::Property *)jarg2;
20495   if (!argp2) {
20496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20497     return ;
20498   }
20499   arg2 = *argp2;
20500   argp3 = (Dali::Property *)jarg3;
20501   if (!argp3) {
20502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20503     return ;
20504   }
20505   arg3 = *argp3;
20506   arg4 = (Dali::Vector2 *)jarg4;
20507   if (!arg4) {
20508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20509     return ;
20510   }
20511   {
20512     try {
20513       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
20514     } CALL_CATCH_EXCEPTION();
20515   }
20516
20517 }
20518
20519
20520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
20521   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20522   Dali::Handle *arg2 = 0 ;
20523
20524   arg1 = (Dali::PathConstrainer *)jarg1;
20525   arg2 = (Dali::Handle *)jarg2;
20526   if (!arg2) {
20527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
20528     return ;
20529   }
20530   {
20531     try {
20532       (arg1)->Remove(*arg2);
20533     } CALL_CATCH_EXCEPTION();
20534   }
20535
20536 }
20537
20538
20539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
20540   int jresult ;
20541   Dali::FittingMode::Type result;
20542
20543   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
20544   jresult = (int)result;
20545   return jresult;
20546 }
20547
20548
20549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
20550   int jresult ;
20551   Dali::SamplingMode::Type result;
20552
20553   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
20554   jresult = (int)result;
20555   return jresult;
20556 }
20557
20558
20559 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
20560   bool jresult ;
20561   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20562   bool result;
20563
20564   arg1 = (Dali::NativeImageInterface *)jarg1;
20565   {
20566     try {
20567       result = (bool)(arg1)->CreateResource();
20568     } CALL_CATCH_EXCEPTION(0);
20569   }
20570
20571   jresult = result;
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
20577   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20578
20579   arg1 = (Dali::NativeImageInterface *)jarg1;
20580   {
20581     try {
20582       (arg1)->DestroyResource();
20583     } CALL_CATCH_EXCEPTION();
20584   }
20585
20586 }
20587
20588
20589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
20590   unsigned int jresult ;
20591   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20592   unsigned int result;
20593
20594   arg1 = (Dali::NativeImageInterface *)jarg1;
20595   {
20596     try {
20597       result = (unsigned int)(arg1)->TargetTexture();
20598     } CALL_CATCH_EXCEPTION(0);
20599   }
20600
20601   jresult = result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
20607   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20608
20609   arg1 = (Dali::NativeImageInterface *)jarg1;
20610   {
20611     try {
20612       (arg1)->PrepareTexture();
20613     } CALL_CATCH_EXCEPTION();
20614   }
20615
20616 }
20617
20618
20619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
20620   unsigned int jresult ;
20621   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20622   unsigned int result;
20623
20624   arg1 = (Dali::NativeImageInterface *)jarg1;
20625   {
20626     try {
20627       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
20628     } CALL_CATCH_EXCEPTION(0);
20629   }
20630
20631   jresult = result;
20632   return jresult;
20633 }
20634
20635
20636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
20637   unsigned int jresult ;
20638   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20639   unsigned int result;
20640
20641   arg1 = (Dali::NativeImageInterface *)jarg1;
20642   {
20643     try {
20644       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
20645     } CALL_CATCH_EXCEPTION(0);
20646   }
20647
20648   jresult = result;
20649   return jresult;
20650 }
20651
20652
20653 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
20654   bool jresult ;
20655   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20656   bool result;
20657
20658   arg1 = (Dali::NativeImageInterface *)jarg1;
20659   {
20660     try {
20661       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
20662     } CALL_CATCH_EXCEPTION(0);
20663   }
20664
20665   jresult = result;
20666   return jresult;
20667 }
20668
20669 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageInterface_GenerateUrl(void* nuiHandle)
20670 {
20671   Dali::Toolkit::ImageUrl result;
20672   Dali::NativeImageInterface* nativeImage = (Dali::NativeImageInterface*)nuiHandle;
20673   void *jresult;
20674
20675   {
20676     try {
20677       result = Dali::Toolkit::Image::GenerateUrl(nativeImage);
20678     }
20679     CALL_CATCH_EXCEPTION(0);
20680   }
20681
20682   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
20683   return jresult;
20684 }
20685
20686
20687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
20688   int jresult ;
20689   int result;
20690
20691   result = (int)Dali::CameraActor::Property::TYPE;
20692   jresult = (int)result;
20693   return jresult;
20694 }
20695
20696
20697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
20698   int jresult ;
20699   int result;
20700
20701   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
20702   jresult = (int)result;
20703   return jresult;
20704 }
20705
20706
20707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
20708   int jresult ;
20709   int result;
20710
20711   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
20712   jresult = (int)result;
20713   return jresult;
20714 }
20715
20716
20717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
20718   int jresult ;
20719   int result;
20720
20721   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
20722   jresult = (int)result;
20723   return jresult;
20724 }
20725
20726
20727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
20728   int jresult ;
20729   int result;
20730
20731   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
20732   jresult = (int)result;
20733   return jresult;
20734 }
20735
20736
20737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
20738   int jresult ;
20739   int result;
20740
20741   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
20742   jresult = (int)result;
20743   return jresult;
20744 }
20745
20746
20747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
20748   int jresult ;
20749   int result;
20750
20751   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
20752   jresult = (int)result;
20753   return jresult;
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
20758   int jresult ;
20759   int result;
20760
20761   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
20762   jresult = (int)result;
20763   return jresult;
20764 }
20765
20766
20767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
20768   int jresult ;
20769   int result;
20770
20771   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
20772   jresult = (int)result;
20773   return jresult;
20774 }
20775
20776
20777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
20778   int jresult ;
20779   int result;
20780
20781   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
20782   jresult = (int)result;
20783   return jresult;
20784 }
20785
20786
20787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
20788   int jresult ;
20789   int result;
20790
20791   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
20792   jresult = (int)result;
20793   return jresult;
20794 }
20795
20796
20797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
20798   int jresult ;
20799   int result;
20800
20801   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
20802   jresult = (int)result;
20803   return jresult;
20804 }
20805
20806
20807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
20808   int jresult ;
20809   int result;
20810
20811   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
20812   jresult = (int)result;
20813   return jresult;
20814 }
20815
20816
20817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
20818   int jresult ;
20819   int result;
20820
20821   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
20822   jresult = (int)result;
20823   return jresult;
20824 }
20825
20826
20827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
20828   int jresult ;
20829   int result;
20830
20831   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
20832   jresult = (int)result;
20833   return jresult;
20834 }
20835
20836
20837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
20838   int jresult ;
20839   int result;
20840
20841   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
20842   jresult = (int)result;
20843   return jresult;
20844 }
20845
20846
20847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
20848   void * jresult ;
20849   Dali::CameraActor::Property *result = 0 ;
20850
20851   {
20852     try {
20853       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
20854     } CALL_CATCH_EXCEPTION(0);
20855   }
20856
20857   jresult = (void *)result;
20858   return jresult;
20859 }
20860
20861
20862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
20863   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
20864
20865   arg1 = (Dali::CameraActor::Property *)jarg1;
20866   {
20867     try {
20868       delete arg1;
20869     } CALL_CATCH_EXCEPTION();
20870   }
20871
20872 }
20873
20874
20875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
20876   void * jresult ;
20877   Dali::CameraActor *result = 0 ;
20878
20879   {
20880     try {
20881       result = (Dali::CameraActor *)new Dali::CameraActor();
20882     } CALL_CATCH_EXCEPTION(0);
20883   }
20884
20885   jresult = (void *)result;
20886   return jresult;
20887 }
20888
20889
20890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
20891   void * jresult ;
20892   Dali::CameraActor result;
20893
20894   {
20895     try {
20896       result = Dali::CameraActor::New();
20897     } CALL_CATCH_EXCEPTION(0);
20898   }
20899
20900   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20901   return jresult;
20902 }
20903
20904
20905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
20906   void * jresult ;
20907   Dali::Size *arg1 = 0 ;
20908   Dali::CameraActor result;
20909
20910   arg1 = (Dali::Size *)jarg1;
20911   if (!arg1) {
20912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
20913     return 0;
20914   }
20915   {
20916     try {
20917       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
20918     } CALL_CATCH_EXCEPTION(0);
20919   }
20920
20921   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20922   return jresult;
20923 }
20924
20925
20926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
20927   void * jresult ;
20928   Dali::CameraActor result;
20929
20930   {
20931     try {
20932       result = Dali::CameraActor::New3DCamera();
20933     } CALL_CATCH_EXCEPTION(0);
20934   }
20935
20936   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20937   return jresult;
20938 }
20939
20940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
20941   void * jresult ;
20942   Dali::BaseHandle arg1 ;
20943   Dali::BaseHandle *argp1 ;
20944   Dali::CameraActor result;
20945
20946   argp1 = (Dali::BaseHandle *)jarg1;
20947   if (!argp1) {
20948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20949     return 0;
20950   }
20951   arg1 = *argp1;
20952   {
20953     try {
20954       result = Dali::CameraActor::DownCast(arg1);
20955     } CALL_CATCH_EXCEPTION(0);
20956   }
20957
20958   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20959   return jresult;
20960 }
20961
20962
20963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
20964   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20965
20966   arg1 = (Dali::CameraActor *)jarg1;
20967   {
20968     try {
20969       delete arg1;
20970     } CALL_CATCH_EXCEPTION();
20971   }
20972
20973 }
20974
20975
20976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
20977   void * jresult ;
20978   Dali::CameraActor *arg1 = 0 ;
20979   Dali::CameraActor *result = 0 ;
20980
20981   arg1 = (Dali::CameraActor *)jarg1;
20982   if (!arg1) {
20983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
20984     return 0;
20985   }
20986   {
20987     try {
20988       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
20989     } CALL_CATCH_EXCEPTION(0);
20990   }
20991
20992   jresult = (void *)result;
20993   return jresult;
20994 }
20995
20996
20997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
20998   void * jresult ;
20999   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21000   Dali::CameraActor *arg2 = 0 ;
21001   Dali::CameraActor *result = 0 ;
21002
21003   arg1 = (Dali::CameraActor *)jarg1;
21004   arg2 = (Dali::CameraActor *)jarg2;
21005   if (!arg2) {
21006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
21007     return 0;
21008   }
21009   {
21010     try {
21011       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
21012     } CALL_CATCH_EXCEPTION(0);
21013   }
21014
21015   jresult = (void *)result;
21016   return jresult;
21017 }
21018
21019
21020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
21021   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21022   Dali::Camera::Type arg2 ;
21023
21024   arg1 = (Dali::CameraActor *)jarg1;
21025   arg2 = (Dali::Camera::Type)jarg2;
21026   {
21027     try {
21028       (arg1)->SetType(arg2);
21029     } CALL_CATCH_EXCEPTION();
21030   }
21031
21032 }
21033
21034
21035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
21036   int jresult ;
21037   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21038   Dali::Camera::Type result;
21039
21040   arg1 = (Dali::CameraActor *)jarg1;
21041   {
21042     try {
21043       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
21044     } CALL_CATCH_EXCEPTION(0);
21045   }
21046
21047   jresult = (int)result;
21048   return jresult;
21049 }
21050
21051
21052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
21053   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21054   Dali::Camera::ProjectionMode arg2 ;
21055
21056   arg1 = (Dali::CameraActor *)jarg1;
21057   arg2 = (Dali::Camera::ProjectionMode)jarg2;
21058   {
21059     try {
21060       (arg1)->SetProjectionMode(arg2);
21061     } CALL_CATCH_EXCEPTION();
21062   }
21063
21064 }
21065
21066
21067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
21068   int jresult ;
21069   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21070   Dali::Camera::ProjectionMode result;
21071
21072   arg1 = (Dali::CameraActor *)jarg1;
21073   {
21074     try {
21075       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
21076     } CALL_CATCH_EXCEPTION(0);
21077   }
21078
21079   jresult = (int)result;
21080   return jresult;
21081 }
21082
21083
21084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
21085   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21086   float arg2 ;
21087
21088   arg1 = (Dali::CameraActor *)jarg1;
21089   arg2 = (float)jarg2;
21090   {
21091     try {
21092       (arg1)->SetFieldOfView(arg2);
21093     } CALL_CATCH_EXCEPTION();
21094   }
21095
21096 }
21097
21098
21099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
21100   float jresult ;
21101   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21102   float result;
21103
21104   arg1 = (Dali::CameraActor *)jarg1;
21105   {
21106     try {
21107       result = (float)(arg1)->GetFieldOfView();
21108     } CALL_CATCH_EXCEPTION(0);
21109   }
21110
21111   jresult = result;
21112   return jresult;
21113 }
21114
21115
21116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
21117   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21118   float arg2 ;
21119
21120   arg1 = (Dali::CameraActor *)jarg1;
21121   arg2 = (float)jarg2;
21122   {
21123     try {
21124       (arg1)->SetAspectRatio(arg2);
21125     } CALL_CATCH_EXCEPTION();
21126   }
21127
21128 }
21129
21130
21131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
21132   float jresult ;
21133   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21134   float result;
21135
21136   arg1 = (Dali::CameraActor *)jarg1;
21137   {
21138     try {
21139       result = (float)(arg1)->GetAspectRatio();
21140     } CALL_CATCH_EXCEPTION(0);
21141   }
21142
21143   jresult = result;
21144   return jresult;
21145 }
21146
21147
21148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
21149   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21150   float arg2 ;
21151
21152   arg1 = (Dali::CameraActor *)jarg1;
21153   arg2 = (float)jarg2;
21154   {
21155     try {
21156       (arg1)->SetNearClippingPlane(arg2);
21157     } CALL_CATCH_EXCEPTION();
21158   }
21159
21160 }
21161
21162
21163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
21164   float jresult ;
21165   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21166   float result;
21167
21168   arg1 = (Dali::CameraActor *)jarg1;
21169   {
21170     try {
21171       result = (float)(arg1)->GetNearClippingPlane();
21172     } CALL_CATCH_EXCEPTION(0);
21173   }
21174
21175   jresult = result;
21176   return jresult;
21177 }
21178
21179
21180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
21181   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21182   float arg2 ;
21183
21184   arg1 = (Dali::CameraActor *)jarg1;
21185   arg2 = (float)jarg2;
21186   {
21187     try {
21188       (arg1)->SetFarClippingPlane(arg2);
21189     } CALL_CATCH_EXCEPTION();
21190   }
21191
21192 }
21193
21194
21195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
21196   float jresult ;
21197   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21198   float result;
21199
21200   arg1 = (Dali::CameraActor *)jarg1;
21201   {
21202     try {
21203       result = (float)(arg1)->GetFarClippingPlane();
21204     } CALL_CATCH_EXCEPTION(0);
21205   }
21206
21207   jresult = result;
21208   return jresult;
21209 }
21210
21211
21212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
21213   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21214   Dali::Vector3 *arg2 = 0 ;
21215
21216   arg1 = (Dali::CameraActor *)jarg1;
21217   arg2 = (Dali::Vector3 *)jarg2;
21218   if (!arg2) {
21219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
21220     return ;
21221   }
21222   {
21223     try {
21224       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
21225     } CALL_CATCH_EXCEPTION();
21226   }
21227
21228 }
21229
21230
21231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
21232   void * jresult ;
21233   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21234   Dali::Vector3 result;
21235
21236   arg1 = (Dali::CameraActor *)jarg1;
21237   {
21238     try {
21239       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
21240     } CALL_CATCH_EXCEPTION(0);
21241   }
21242
21243   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
21244   return jresult;
21245 }
21246
21247
21248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
21249   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21250   bool arg2 ;
21251
21252   arg1 = (Dali::CameraActor *)jarg1;
21253   arg2 = jarg2 ? true : false;
21254   {
21255     try {
21256       (arg1)->SetInvertYAxis(arg2);
21257     } CALL_CATCH_EXCEPTION();
21258   }
21259
21260 }
21261
21262
21263 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
21264   bool jresult ;
21265   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21266   bool result;
21267
21268   arg1 = (Dali::CameraActor *)jarg1;
21269   {
21270     try {
21271       result = (bool)(arg1)->GetInvertYAxis();
21272     } CALL_CATCH_EXCEPTION(0);
21273   }
21274
21275   jresult = result;
21276   return jresult;
21277 }
21278
21279
21280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
21281   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21282   Dali::Size *arg2 = 0 ;
21283
21284   arg1 = (Dali::CameraActor *)jarg1;
21285   arg2 = (Dali::Size *)jarg2;
21286   if (!arg2) {
21287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
21288     return ;
21289   }
21290   {
21291     try {
21292       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
21293     } CALL_CATCH_EXCEPTION();
21294   }
21295
21296 }
21297
21298
21299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
21300   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
21301   Dali::Size *arg2 = 0 ;
21302
21303   arg1 = (Dali::CameraActor *)jarg1;
21304   arg2 = (Dali::Size *)jarg2;
21305   if (!arg2) {
21306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
21307     return ;
21308   }
21309   {
21310     try {
21311       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
21312     } CALL_CATCH_EXCEPTION();
21313   }
21314
21315 }
21316
21317
21318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
21319   void * jresult ;
21320   std::pair< std::string,Dali::Property::Value > *result = 0 ;
21321
21322   {
21323     try {
21324       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
21325     } CALL_CATCH_EXCEPTION(0);
21326   }
21327
21328   jresult = (void *)result;
21329   return jresult;
21330 }
21331
21332
21333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
21334   void * jresult ;
21335   std::string arg1 ;
21336   Dali::Property::Value arg2 ;
21337   Dali::Property::Value *argp2 ;
21338   std::pair< std::string,Dali::Property::Value > *result = 0 ;
21339
21340   if (!jarg1) {
21341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21342     return 0;
21343   }
21344   (&arg1)->assign(jarg1);
21345   argp2 = (Dali::Property::Value *)jarg2;
21346   if (!argp2) {
21347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
21348     return 0;
21349   }
21350   arg2 = *argp2;
21351   {
21352     try {
21353       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
21354     } CALL_CATCH_EXCEPTION(0);
21355   }
21356
21357   jresult = (void *)result;
21358   return jresult;
21359 }
21360
21361
21362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
21363   void * jresult ;
21364   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
21365   std::pair< std::string,Dali::Property::Value > *result = 0 ;
21366
21367   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21368   if (!arg1) {
21369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
21370     return 0;
21371   }
21372   {
21373     try {
21374       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);
21375     } CALL_CATCH_EXCEPTION(0);
21376   }
21377
21378   jresult = (void *)result;
21379   return jresult;
21380 }
21381
21382
21383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
21384   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21385   std::string *arg2 = 0 ;
21386
21387   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21388   if (!jarg2) {
21389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21390     return ;
21391   }
21392   std::string arg2_str(jarg2);
21393   arg2 = &arg2_str;
21394   if (arg1) (arg1)->first = *arg2;
21395
21396   //argout typemap for const std::string&
21397
21398 }
21399
21400
21401 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
21402   char * jresult ;
21403   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21404   std::string *result = 0 ;
21405
21406   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21407   result = (std::string *) & ((arg1)->first);
21408   jresult = SWIG_csharp_string_callback(result->c_str());
21409   return jresult;
21410 }
21411
21412
21413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
21414   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21415   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
21416
21417   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21418   arg2 = (Dali::Property::Value *)jarg2;
21419   if (arg1) (arg1)->second = *arg2;
21420 }
21421
21422
21423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
21424   void * jresult ;
21425   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21426   Dali::Property::Value *result = 0 ;
21427
21428   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21429   result = (Dali::Property::Value *)& ((arg1)->second);
21430   jresult = (void *)result;
21431   return jresult;
21432 }
21433
21434
21435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
21436   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21437
21438   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21439   {
21440     try {
21441       delete arg1;
21442     } CALL_CATCH_EXCEPTION();
21443   }
21444
21445 }
21446
21447
21448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
21449   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21450
21451   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21452   {
21453     try {
21454       (arg1)->clear();
21455     } CALL_CATCH_EXCEPTION();
21456   }
21457
21458 }
21459
21460
21461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
21462   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21463   Dali::TouchPoint *arg2 = 0 ;
21464
21465   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21466   arg2 = (Dali::TouchPoint *)jarg2;
21467   if (!arg2) {
21468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21469     return ;
21470   }
21471   {
21472     try {
21473       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
21474     } CALL_CATCH_EXCEPTION();
21475   }
21476
21477 }
21478
21479
21480 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
21481   unsigned long jresult ;
21482   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21483   std::vector< Dali::TouchPoint >::size_type result;
21484
21485   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21486   {
21487     try {
21488       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
21489     } CALL_CATCH_EXCEPTION(0);
21490   }
21491
21492   jresult = (unsigned long)result;
21493   return jresult;
21494 }
21495
21496
21497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
21498   unsigned long jresult ;
21499   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21500   std::vector< Dali::TouchPoint >::size_type result;
21501
21502   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21503   {
21504     try {
21505       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
21506     } CALL_CATCH_EXCEPTION(0);
21507   }
21508
21509   jresult = (unsigned long)result;
21510   return jresult;
21511 }
21512
21513
21514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
21515   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21516   std::vector< Dali::TouchPoint >::size_type arg2 ;
21517
21518   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21519   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
21520   {
21521     try {
21522       (arg1)->reserve(arg2);
21523     } CALL_CATCH_EXCEPTION();
21524   }
21525
21526 }
21527
21528
21529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
21530   void * jresult ;
21531   std::vector< Dali::TouchPoint > *result = 0 ;
21532
21533   {
21534     try {
21535       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
21536     } CALL_CATCH_EXCEPTION(0);
21537   }
21538
21539   jresult = (void *)result;
21540   return jresult;
21541 }
21542
21543
21544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
21545   void * jresult ;
21546   std::vector< Dali::TouchPoint > *arg1 = 0 ;
21547   std::vector< Dali::TouchPoint > *result = 0 ;
21548
21549   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21550   if (!arg1) {
21551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21552     return 0;
21553   }
21554   {
21555     try {
21556       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
21557     } CALL_CATCH_EXCEPTION(0);
21558   }
21559
21560   jresult = (void *)result;
21561   return jresult;
21562 }
21563
21564
21565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
21566   void * jresult ;
21567   int arg1 ;
21568   std::vector< Dali::TouchPoint > *result = 0 ;
21569
21570   arg1 = (int)jarg1;
21571   {
21572     try {
21573       try {
21574         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
21575       }
21576       catch(std::out_of_range &_e) {
21577         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21578         return 0;
21579       }
21580
21581     } CALL_CATCH_EXCEPTION(0);
21582   }
21583
21584   jresult = (void *)result;
21585   return jresult;
21586 }
21587
21588
21589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
21590   void * jresult ;
21591   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21592   int arg2 ;
21593   SwigValueWrapper< Dali::TouchPoint > result;
21594
21595   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21596   arg2 = (int)jarg2;
21597   {
21598     try {
21599       try {
21600         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
21601       }
21602       catch(std::out_of_range &_e) {
21603         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21604         return 0;
21605       }
21606
21607     } CALL_CATCH_EXCEPTION(0);
21608   }
21609
21610   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
21611   return jresult;
21612 }
21613
21614
21615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
21616   void * jresult ;
21617   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21618   int arg2 ;
21619   Dali::TouchPoint *result = 0 ;
21620
21621   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21622   arg2 = (int)jarg2;
21623   {
21624     try {
21625       try {
21626         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
21627       }
21628       catch(std::out_of_range &_e) {
21629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21630         return 0;
21631       }
21632
21633     } CALL_CATCH_EXCEPTION(0);
21634   }
21635
21636   jresult = (void *)result;
21637   return jresult;
21638 }
21639
21640
21641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
21642   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21643   int arg2 ;
21644   Dali::TouchPoint *arg3 = 0 ;
21645
21646   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21647   arg2 = (int)jarg2;
21648   arg3 = (Dali::TouchPoint *)jarg3;
21649   if (!arg3) {
21650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21651     return ;
21652   }
21653   {
21654     try {
21655       try {
21656         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
21657       }
21658       catch(std::out_of_range &_e) {
21659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21660         return ;
21661       }
21662
21663     } CALL_CATCH_EXCEPTION();
21664   }
21665
21666 }
21667
21668
21669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
21670   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21671   std::vector< Dali::TouchPoint > *arg2 = 0 ;
21672
21673   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21674   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
21675   if (!arg2) {
21676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21677     return ;
21678   }
21679   {
21680     try {
21681       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
21682     } CALL_CATCH_EXCEPTION();
21683   }
21684
21685 }
21686
21687
21688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
21689   void * jresult ;
21690   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21691   int arg2 ;
21692   int arg3 ;
21693   std::vector< Dali::TouchPoint > *result = 0 ;
21694
21695   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21696   arg2 = (int)jarg2;
21697   arg3 = (int)jarg3;
21698   {
21699     try {
21700       try {
21701         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
21702       }
21703       catch(std::out_of_range &_e) {
21704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21705         return 0;
21706       }
21707       catch(std::invalid_argument &_e) {
21708         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21709         return 0;
21710       }
21711
21712     } CALL_CATCH_EXCEPTION(0);
21713   }
21714
21715   jresult = (void *)result;
21716   return jresult;
21717 }
21718
21719
21720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
21721   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21722   int arg2 ;
21723   Dali::TouchPoint *arg3 = 0 ;
21724
21725   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21726   arg2 = (int)jarg2;
21727   arg3 = (Dali::TouchPoint *)jarg3;
21728   if (!arg3) {
21729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21730     return ;
21731   }
21732   {
21733     try {
21734       try {
21735         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
21736       }
21737       catch(std::out_of_range &_e) {
21738         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21739         return ;
21740       }
21741
21742     } CALL_CATCH_EXCEPTION();
21743   }
21744
21745 }
21746
21747
21748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
21749   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21750   int arg2 ;
21751   std::vector< Dali::TouchPoint > *arg3 = 0 ;
21752
21753   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21754   arg2 = (int)jarg2;
21755   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
21756   if (!arg3) {
21757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21758     return ;
21759   }
21760   {
21761     try {
21762       try {
21763         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
21764       }
21765       catch(std::out_of_range &_e) {
21766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21767         return ;
21768       }
21769
21770     } CALL_CATCH_EXCEPTION();
21771   }
21772
21773 }
21774
21775
21776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
21777   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21778   int arg2 ;
21779
21780   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21781   arg2 = (int)jarg2;
21782   {
21783     try {
21784       try {
21785         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
21786       }
21787       catch(std::out_of_range &_e) {
21788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21789         return ;
21790       }
21791
21792     } CALL_CATCH_EXCEPTION();
21793   }
21794
21795 }
21796
21797
21798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
21799   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21800   int arg2 ;
21801   int arg3 ;
21802
21803   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21804   arg2 = (int)jarg2;
21805   arg3 = (int)jarg3;
21806   {
21807     try {
21808       try {
21809         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
21810       }
21811       catch(std::out_of_range &_e) {
21812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21813         return ;
21814       }
21815       catch(std::invalid_argument &_e) {
21816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21817         return ;
21818       }
21819
21820     } CALL_CATCH_EXCEPTION();
21821   }
21822
21823 }
21824
21825
21826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
21827   void * jresult ;
21828   Dali::TouchPoint *arg1 = 0 ;
21829   int arg2 ;
21830   std::vector< Dali::TouchPoint > *result = 0 ;
21831
21832   arg1 = (Dali::TouchPoint *)jarg1;
21833   if (!arg1) {
21834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21835     return 0;
21836   }
21837   arg2 = (int)jarg2;
21838   {
21839     try {
21840       try {
21841         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
21842       }
21843       catch(std::out_of_range &_e) {
21844         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21845         return 0;
21846       }
21847
21848     } CALL_CATCH_EXCEPTION(0);
21849   }
21850
21851   jresult = (void *)result;
21852   return jresult;
21853 }
21854
21855
21856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
21857   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21858
21859   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21860   {
21861     try {
21862       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
21863     } CALL_CATCH_EXCEPTION();
21864   }
21865
21866 }
21867
21868
21869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
21870   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21871   int arg2 ;
21872   int arg3 ;
21873
21874   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21875   arg2 = (int)jarg2;
21876   arg3 = (int)jarg3;
21877   {
21878     try {
21879       try {
21880         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
21881       }
21882       catch(std::out_of_range &_e) {
21883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21884         return ;
21885       }
21886       catch(std::invalid_argument &_e) {
21887         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21888         return ;
21889       }
21890
21891     } CALL_CATCH_EXCEPTION();
21892   }
21893
21894 }
21895
21896
21897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
21898   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21899   int arg2 ;
21900   std::vector< Dali::TouchPoint > *arg3 = 0 ;
21901
21902   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21903   arg2 = (int)jarg2;
21904   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
21905   if (!arg3) {
21906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21907     return ;
21908   }
21909   {
21910     try {
21911       try {
21912         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
21913       }
21914       catch(std::out_of_range &_e) {
21915         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21916         return ;
21917       }
21918
21919     } CALL_CATCH_EXCEPTION();
21920   }
21921
21922 }
21923
21924
21925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
21926   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21927
21928   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21929   {
21930     try {
21931       delete arg1;
21932     } CALL_CATCH_EXCEPTION();
21933   }
21934
21935 }
21936
21937
21938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
21939   void * jresult ;
21940   Dali::Rect< int > *result = 0 ;
21941
21942   {
21943     try {
21944       result = (Dali::Rect< int > *)new Dali::Rect< int >();
21945     } CALL_CATCH_EXCEPTION(0);
21946   }
21947
21948   jresult = (void *)result;
21949   return jresult;
21950 }
21951
21952
21953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
21954   void * jresult ;
21955   int arg1 ;
21956   int arg2 ;
21957   int arg3 ;
21958   int arg4 ;
21959   Dali::Rect< int > *result = 0 ;
21960
21961   arg1 = (int)jarg1;
21962   arg2 = (int)jarg2;
21963   arg3 = (int)jarg3;
21964   arg4 = (int)jarg4;
21965   {
21966     try {
21967       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
21968     } CALL_CATCH_EXCEPTION(0);
21969   }
21970
21971   jresult = (void *)result;
21972   return jresult;
21973 }
21974
21975
21976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
21977   void * jresult ;
21978   Dali::Rect< int > *arg1 = 0 ;
21979   Dali::Rect< int > *result = 0 ;
21980
21981   arg1 = (Dali::Rect< int > *)jarg1;
21982   if (!arg1) {
21983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
21984     return 0;
21985   }
21986   {
21987     try {
21988       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
21989     } CALL_CATCH_EXCEPTION(0);
21990   }
21991
21992   jresult = (void *)result;
21993   return jresult;
21994 }
21995
21996
21997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
21998   void * jresult ;
21999   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22000   Dali::Rect< int > *arg2 = 0 ;
22001   Dali::Rect< int > *result = 0 ;
22002
22003   arg1 = (Dali::Rect< int > *)jarg1;
22004   arg2 = (Dali::Rect< int > *)jarg2;
22005   if (!arg2) {
22006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
22007     return 0;
22008   }
22009   {
22010     try {
22011       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
22012     } CALL_CATCH_EXCEPTION(0);
22013   }
22014
22015   jresult = (void *)result;
22016   return jresult;
22017 }
22018
22019
22020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
22021   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22022   int arg2 ;
22023   int arg3 ;
22024   int arg4 ;
22025   int arg5 ;
22026
22027   arg1 = (Dali::Rect< int > *)jarg1;
22028   arg2 = (int)jarg2;
22029   arg3 = (int)jarg3;
22030   arg4 = (int)jarg4;
22031   arg5 = (int)jarg5;
22032   {
22033     try {
22034       (arg1)->Set(arg2,arg3,arg4,arg5);
22035     } CALL_CATCH_EXCEPTION();
22036   }
22037
22038 }
22039
22040
22041 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
22042   bool jresult ;
22043   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22044   bool result;
22045
22046   arg1 = (Dali::Rect< int > *)jarg1;
22047   {
22048     try {
22049       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
22050     } CALL_CATCH_EXCEPTION(0);
22051   }
22052
22053   jresult = result;
22054   return jresult;
22055 }
22056
22057
22058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
22059   int jresult ;
22060   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22061   int result;
22062
22063   arg1 = (Dali::Rect< int > *)jarg1;
22064   {
22065     try {
22066       result = (int)((Dali::Rect< int > const *)arg1)->Left();
22067     } CALL_CATCH_EXCEPTION(0);
22068   }
22069
22070   jresult = result;
22071   return jresult;
22072 }
22073
22074
22075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
22076   int jresult ;
22077   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22078   int result;
22079
22080   arg1 = (Dali::Rect< int > *)jarg1;
22081   {
22082     try {
22083       result = (int)((Dali::Rect< int > const *)arg1)->Right();
22084     } CALL_CATCH_EXCEPTION(0);
22085   }
22086
22087   jresult = result;
22088   return jresult;
22089 }
22090
22091
22092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
22093   int jresult ;
22094   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22095   int result;
22096
22097   arg1 = (Dali::Rect< int > *)jarg1;
22098   {
22099     try {
22100       result = (int)((Dali::Rect< int > const *)arg1)->Top();
22101     } CALL_CATCH_EXCEPTION(0);
22102   }
22103
22104   jresult = result;
22105   return jresult;
22106 }
22107
22108
22109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
22110   int jresult ;
22111   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22112   int result;
22113
22114   arg1 = (Dali::Rect< int > *)jarg1;
22115   {
22116     try {
22117       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
22118     } CALL_CATCH_EXCEPTION(0);
22119   }
22120
22121   jresult = result;
22122   return jresult;
22123 }
22124
22125
22126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
22127   int jresult ;
22128   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22129   int result;
22130
22131   arg1 = (Dali::Rect< int > *)jarg1;
22132   {
22133     try {
22134       result = (int)((Dali::Rect< int > const *)arg1)->Area();
22135     } CALL_CATCH_EXCEPTION(0);
22136   }
22137
22138   jresult = result;
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
22144   bool jresult ;
22145   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22146   Dali::Rect< int > *arg2 = 0 ;
22147   bool result;
22148
22149   arg1 = (Dali::Rect< int > *)jarg1;
22150   arg2 = (Dali::Rect< int > *)jarg2;
22151   if (!arg2) {
22152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
22153     return 0;
22154   }
22155   {
22156     try {
22157       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
22158     } CALL_CATCH_EXCEPTION(0);
22159   }
22160
22161   jresult = result;
22162   return jresult;
22163 }
22164
22165
22166 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
22167   bool jresult ;
22168   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22169   Dali::Rect< int > *arg2 = 0 ;
22170   bool result;
22171
22172   arg1 = (Dali::Rect< int > *)jarg1;
22173   arg2 = (Dali::Rect< int > *)jarg2;
22174   if (!arg2) {
22175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
22176     return 0;
22177   }
22178   {
22179     try {
22180       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
22181     } CALL_CATCH_EXCEPTION(0);
22182   }
22183
22184   jresult = result;
22185   return jresult;
22186 }
22187
22188
22189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
22190   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22191   int arg2 ;
22192
22193   arg1 = (Dali::Rect< int > *)jarg1;
22194   arg2 = (int)jarg2;
22195   if (arg1) (arg1)->x = arg2;
22196 }
22197
22198
22199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
22200   int jresult ;
22201   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22202   int result;
22203
22204   arg1 = (Dali::Rect< int > *)jarg1;
22205   result = (int) ((arg1)->x);
22206   jresult = result;
22207   return jresult;
22208 }
22209
22210
22211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
22212   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22213   int arg2 ;
22214
22215   arg1 = (Dali::Rect< int > *)jarg1;
22216   arg2 = (int)jarg2;
22217   if (arg1) (arg1)->left = arg2;
22218 }
22219
22220
22221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
22222   int jresult ;
22223   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22224   int result;
22225
22226   arg1 = (Dali::Rect< int > *)jarg1;
22227   result = (int) ((arg1)->left);
22228   jresult = result;
22229   return jresult;
22230 }
22231
22232
22233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
22234   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22235   int arg2 ;
22236
22237   arg1 = (Dali::Rect< int > *)jarg1;
22238   arg2 = (int)jarg2;
22239   if (arg1) (arg1)->y = arg2;
22240 }
22241
22242
22243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
22244   int jresult ;
22245   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22246   int result;
22247
22248   arg1 = (Dali::Rect< int > *)jarg1;
22249   result = (int) ((arg1)->y);
22250   jresult = result;
22251   return jresult;
22252 }
22253
22254
22255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
22256   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22257   int arg2 ;
22258
22259   arg1 = (Dali::Rect< int > *)jarg1;
22260   arg2 = (int)jarg2;
22261   if (arg1) (arg1)->right = arg2;
22262 }
22263
22264
22265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
22266   int jresult ;
22267   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22268   int result;
22269
22270   arg1 = (Dali::Rect< int > *)jarg1;
22271   result = (int) ((arg1)->right);
22272   jresult = result;
22273   return jresult;
22274 }
22275
22276
22277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
22278   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22279   int arg2 ;
22280
22281   arg1 = (Dali::Rect< int > *)jarg1;
22282   arg2 = (int)jarg2;
22283   if (arg1) (arg1)->width = arg2;
22284 }
22285
22286
22287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
22288   int jresult ;
22289   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22290   int result;
22291
22292   arg1 = (Dali::Rect< int > *)jarg1;
22293   result = (int) ((arg1)->width);
22294   jresult = result;
22295   return jresult;
22296 }
22297
22298
22299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
22300   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22301   int arg2 ;
22302
22303   arg1 = (Dali::Rect< int > *)jarg1;
22304   arg2 = (int)jarg2;
22305   if (arg1) (arg1)->bottom = arg2;
22306 }
22307
22308
22309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
22310   int jresult ;
22311   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22312   int result;
22313
22314   arg1 = (Dali::Rect< int > *)jarg1;
22315   result = (int) ((arg1)->bottom);
22316   jresult = result;
22317   return jresult;
22318 }
22319
22320
22321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
22322   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22323   int arg2 ;
22324
22325   arg1 = (Dali::Rect< int > *)jarg1;
22326   arg2 = (int)jarg2;
22327   if (arg1) (arg1)->height = arg2;
22328 }
22329
22330
22331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
22332   int jresult ;
22333   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22334   int result;
22335
22336   arg1 = (Dali::Rect< int > *)jarg1;
22337   result = (int) ((arg1)->height);
22338   jresult = result;
22339   return jresult;
22340 }
22341
22342
22343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
22344   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22345   int arg2 ;
22346
22347   arg1 = (Dali::Rect< int > *)jarg1;
22348   arg2 = (int)jarg2;
22349   if (arg1) (arg1)->top = arg2;
22350 }
22351
22352
22353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
22354   int jresult ;
22355   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22356   int result;
22357
22358   arg1 = (Dali::Rect< int > *)jarg1;
22359   result = (int) ((arg1)->top);
22360   jresult = result;
22361   return jresult;
22362 }
22363
22364
22365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
22366   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
22367
22368   arg1 = (Dali::Rect< int > *)jarg1;
22369   {
22370     try {
22371       delete arg1;
22372     } CALL_CATCH_EXCEPTION();
22373   }
22374
22375 }
22376
22377
22378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
22379   void * jresult ;
22380   Dali::Rect< float > *result = 0 ;
22381
22382   {
22383     try {
22384       result = (Dali::Rect< float > *)new Dali::Rect< float >();
22385     } CALL_CATCH_EXCEPTION(0);
22386   }
22387
22388   jresult = (void *)result;
22389   return jresult;
22390 }
22391
22392
22393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
22394   void * jresult ;
22395   float arg1 ;
22396   float arg2 ;
22397   float arg3 ;
22398   float arg4 ;
22399   Dali::Rect< float > *result = 0 ;
22400
22401   arg1 = (float)jarg1;
22402   arg2 = (float)jarg2;
22403   arg3 = (float)jarg4;
22404   arg4 = (float)jarg3;
22405   {
22406     try {
22407       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
22408     } CALL_CATCH_EXCEPTION(0);
22409   }
22410
22411   jresult = (void *)result;
22412   return jresult;
22413 }
22414
22415
22416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
22417   void * jresult ;
22418   Dali::Rect< float > *arg1 = 0 ;
22419   Dali::Rect< float > *result = 0 ;
22420
22421   arg1 = (Dali::Rect< float > *)jarg1;
22422   if (!arg1) {
22423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
22424     return 0;
22425   }
22426   {
22427     try {
22428       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
22429     } CALL_CATCH_EXCEPTION(0);
22430   }
22431
22432   jresult = (void *)result;
22433   return jresult;
22434 }
22435
22436
22437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
22438   void * jresult ;
22439   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22440   Dali::Rect< float > *arg2 = 0 ;
22441   Dali::Rect< float > *result = 0 ;
22442
22443   arg1 = (Dali::Rect< float > *)jarg1;
22444   arg2 = (Dali::Rect< float > *)jarg2;
22445   if (!arg2) {
22446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
22447     return 0;
22448   }
22449   {
22450     try {
22451       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
22452     } CALL_CATCH_EXCEPTION(0);
22453   }
22454
22455   jresult = (void *)result;
22456   return jresult;
22457 }
22458
22459
22460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
22461   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22462   float arg2 ;
22463   float arg3 ;
22464   float arg4 ;
22465   float arg5 ;
22466
22467   arg1 = (Dali::Rect< float > *)jarg1;
22468   arg2 = (float)jarg2;
22469   arg3 = (float)jarg3;
22470   arg4 = (float)jarg5;
22471   arg5 = (float)jarg4;
22472   {
22473     try {
22474       (arg1)->Set(arg2,arg3,arg4,arg5);
22475     } CALL_CATCH_EXCEPTION();
22476   }
22477
22478 }
22479
22480
22481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
22482   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22483   float arg2 ;
22484
22485   arg1 = (Dali::Rect< float > *)jarg1;
22486   arg2 = (float)jarg2;
22487   if (arg1) (arg1)->left = arg2;
22488 }
22489
22490
22491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
22492   float jresult ;
22493   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22494   float result;
22495
22496   arg1 = (Dali::Rect< float > *)jarg1;
22497   result = (float) ((arg1)->left);
22498   jresult = result;
22499   return jresult;
22500 }
22501
22502
22503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
22504   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22505   float arg2 ;
22506
22507   arg1 = (Dali::Rect< float > *)jarg1;
22508   arg2 = (float)jarg2;
22509   if (arg1) (arg1)->left = arg2;
22510 }
22511
22512
22513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
22514   float jresult ;
22515   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22516   float result;
22517
22518   arg1 = (Dali::Rect< float > *)jarg1;
22519   result = (float) ((arg1)->left);
22520   jresult = result;
22521   return jresult;
22522 }
22523
22524
22525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
22526   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22527   float arg2 ;
22528
22529   arg1 = (Dali::Rect< float > *)jarg1;
22530   arg2 = (float)jarg2;
22531   if (arg1) (arg1)->right = arg2;
22532 }
22533
22534
22535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
22536   float jresult ;
22537   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22538   float result;
22539
22540   arg1 = (Dali::Rect< float > *)jarg1;
22541   result = (float) ((arg1)->right);
22542   jresult = result;
22543   return jresult;
22544 }
22545
22546
22547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
22548   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22549   float arg2 ;
22550
22551   arg1 = (Dali::Rect< float > *)jarg1;
22552   arg2 = (float)jarg2;
22553   if (arg1) (arg1)->right = arg2;
22554 }
22555
22556
22557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
22558   float jresult ;
22559   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22560   float result;
22561
22562   arg1 = (Dali::Rect< float > *)jarg1;
22563   result = (float) ((arg1)->right);
22564   jresult = result;
22565   return jresult;
22566 }
22567
22568
22569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
22570   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22571   float arg2 ;
22572
22573   arg1 = (Dali::Rect< float > *)jarg1;
22574   arg2 = (float)jarg2;
22575   if (arg1) (arg1)->bottom = arg2;
22576 }
22577
22578
22579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
22580   float jresult ;
22581   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22582   float result;
22583
22584   arg1 = (Dali::Rect< float > *)jarg1;
22585   result = (float) ((arg1)->bottom);
22586   jresult = result;
22587   return jresult;
22588 }
22589
22590
22591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
22592   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22593   float arg2 ;
22594
22595   arg1 = (Dali::Rect< float > *)jarg1;
22596   arg2 = (float)jarg2;
22597   if (arg1) (arg1)->top = arg2;
22598 }
22599
22600
22601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
22602   float jresult ;
22603   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22604   float result;
22605
22606   arg1 = (Dali::Rect< float > *)jarg1;
22607   result = (float) ((arg1)->top);
22608   jresult = result;
22609   return jresult;
22610 }
22611
22612
22613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
22614   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22615
22616   arg1 = (Dali::Rect< float > *)jarg1;
22617   {
22618     try {
22619       delete arg1;
22620     } CALL_CATCH_EXCEPTION();
22621   }
22622
22623 }
22624
22625
22626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
22627   int jresult ;
22628   int result;
22629
22630   result = (int)Dali::Vector< int >::BaseType;
22631   jresult = (int)result;
22632   return jresult;
22633 }
22634
22635
22636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
22637   void * jresult ;
22638   Dali::Vector< int > *result = 0 ;
22639
22640   {
22641     try {
22642       result = (Dali::Vector< int > *)new Dali::Vector< int >();
22643     } CALL_CATCH_EXCEPTION(0);
22644   }
22645
22646   jresult = (void *)result;
22647   return jresult;
22648 }
22649
22650
22651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
22652   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22653
22654   arg1 = (Dali::Vector< int > *)jarg1;
22655   {
22656     try {
22657       delete arg1;
22658     } CALL_CATCH_EXCEPTION();
22659   }
22660
22661 }
22662
22663
22664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
22665   void * jresult ;
22666   Dali::Vector< int > *arg1 = 0 ;
22667   Dali::Vector< int > *result = 0 ;
22668
22669   arg1 = (Dali::Vector< int > *)jarg1;
22670   if (!arg1) {
22671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
22672     return 0;
22673   }
22674   {
22675     try {
22676       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
22677     } CALL_CATCH_EXCEPTION(0);
22678   }
22679
22680   jresult = (void *)result;
22681   return jresult;
22682 }
22683
22684
22685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
22686   void * jresult ;
22687   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22688   Dali::Vector< int > *arg2 = 0 ;
22689   Dali::Vector< int > *result = 0 ;
22690
22691   arg1 = (Dali::Vector< int > *)jarg1;
22692   arg2 = (Dali::Vector< int > *)jarg2;
22693   if (!arg2) {
22694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
22695     return 0;
22696   }
22697   {
22698     try {
22699       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
22700     } CALL_CATCH_EXCEPTION(0);
22701   }
22702
22703   jresult = (void *)result;
22704   return jresult;
22705 }
22706
22707
22708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
22709   void * jresult ;
22710   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22711   Dali::Vector< int >::Iterator result;
22712
22713   arg1 = (Dali::Vector< int > *)jarg1;
22714   {
22715     try {
22716       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
22717     } CALL_CATCH_EXCEPTION(0);
22718   }
22719
22720   jresult = (void *)result;
22721   return jresult;
22722 }
22723
22724
22725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
22726   void * jresult ;
22727   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22728   Dali::Vector< int >::Iterator result;
22729
22730   arg1 = (Dali::Vector< int > *)jarg1;
22731   {
22732     try {
22733       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
22734     } CALL_CATCH_EXCEPTION(0);
22735   }
22736
22737   jresult = (void *)result;
22738   return jresult;
22739 }
22740
22741
22742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
22743   void * jresult ;
22744   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22745   Dali::Vector< int >::SizeType arg2 ;
22746   Dali::Vector< int >::ItemType *result = 0 ;
22747
22748   arg1 = (Dali::Vector< int > *)jarg1;
22749   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22750   {
22751     try {
22752       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
22753     } CALL_CATCH_EXCEPTION(0);
22754   }
22755
22756   jresult = (void *)result;
22757   return jresult;
22758 }
22759
22760
22761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
22762   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22763   Dali::Vector< int >::ItemType *arg2 = 0 ;
22764   Dali::Vector< int >::ItemType temp2 ;
22765
22766   arg1 = (Dali::Vector< int > *)jarg1;
22767   temp2 = (Dali::Vector< int >::ItemType)jarg2;
22768   arg2 = &temp2;
22769   {
22770     try {
22771       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
22772     } CALL_CATCH_EXCEPTION();
22773   }
22774
22775 }
22776
22777
22778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
22779   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22780   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22781   Dali::Vector< int >::ItemType *arg3 = 0 ;
22782   Dali::Vector< int >::ItemType temp3 ;
22783
22784   arg1 = (Dali::Vector< int > *)jarg1;
22785   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22786   temp3 = (Dali::Vector< int >::ItemType)jarg3;
22787   arg3 = &temp3;
22788   {
22789     try {
22790       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
22791     } CALL_CATCH_EXCEPTION();
22792   }
22793
22794 }
22795
22796
22797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
22798   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22799   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22800   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
22801   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
22802
22803   arg1 = (Dali::Vector< int > *)jarg1;
22804   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22805   arg3 = (Dali::Vector< int >::Iterator)jarg3;
22806   arg4 = (Dali::Vector< int >::Iterator)jarg4;
22807   {
22808     try {
22809       (arg1)->Insert(arg2,arg3,arg4);
22810     } CALL_CATCH_EXCEPTION();
22811   }
22812
22813 }
22814
22815
22816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
22817   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22818   Dali::Vector< int >::SizeType arg2 ;
22819
22820   arg1 = (Dali::Vector< int > *)jarg1;
22821   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22822   {
22823     try {
22824       (arg1)->Reserve(arg2);
22825     } CALL_CATCH_EXCEPTION();
22826   }
22827
22828 }
22829
22830
22831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
22832   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22833   Dali::Vector< int >::SizeType arg2 ;
22834
22835   arg1 = (Dali::Vector< int > *)jarg1;
22836   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22837   {
22838     try {
22839       (arg1)->Resize(arg2);
22840     } CALL_CATCH_EXCEPTION();
22841   }
22842
22843 }
22844
22845
22846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
22847   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22848   Dali::Vector< int >::SizeType arg2 ;
22849   Dali::Vector< int >::ItemType *arg3 = 0 ;
22850   Dali::Vector< int >::ItemType temp3 ;
22851
22852   arg1 = (Dali::Vector< int > *)jarg1;
22853   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22854   temp3 = (Dali::Vector< int >::ItemType)jarg3;
22855   arg3 = &temp3;
22856   {
22857     try {
22858       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
22859     } CALL_CATCH_EXCEPTION();
22860   }
22861
22862 }
22863
22864
22865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
22866   void * jresult ;
22867   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22868   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22869   Dali::Vector< int >::Iterator result;
22870
22871   arg1 = (Dali::Vector< int > *)jarg1;
22872   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22873   {
22874     try {
22875       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
22876     } CALL_CATCH_EXCEPTION(0);
22877   }
22878
22879   jresult = (void *)result;
22880   return jresult;
22881 }
22882
22883
22884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22885   void * jresult ;
22886   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22887   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22888   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
22889   Dali::Vector< int >::Iterator result;
22890
22891   arg1 = (Dali::Vector< int > *)jarg1;
22892   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22893   arg3 = (Dali::Vector< int >::Iterator)jarg3;
22894   {
22895     try {
22896       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
22897     } CALL_CATCH_EXCEPTION(0);
22898   }
22899
22900   jresult = (void *)result;
22901   return jresult;
22902 }
22903
22904
22905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
22906   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22907   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22908
22909   arg1 = (Dali::Vector< int > *)jarg1;
22910   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22911   {
22912     try {
22913       (arg1)->Remove(arg2);
22914     } CALL_CATCH_EXCEPTION();
22915   }
22916
22917 }
22918
22919
22920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
22921   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22922   Dali::Vector< int > *arg2 = 0 ;
22923
22924   arg1 = (Dali::Vector< int > *)jarg1;
22925   arg2 = (Dali::Vector< int > *)jarg2;
22926   if (!arg2) {
22927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
22928     return ;
22929   }
22930   {
22931     try {
22932       (arg1)->Swap(*arg2);
22933     } CALL_CATCH_EXCEPTION();
22934   }
22935
22936 }
22937
22938
22939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
22940   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22941
22942   arg1 = (Dali::Vector< int > *)jarg1;
22943   {
22944     try {
22945       (arg1)->Clear();
22946     } CALL_CATCH_EXCEPTION();
22947   }
22948
22949 }
22950
22951
22952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
22953   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22954
22955   arg1 = (Dali::Vector< int > *)jarg1;
22956   {
22957     try {
22958       (arg1)->Release();
22959     } CALL_CATCH_EXCEPTION();
22960   }
22961
22962 }
22963
22964
22965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
22966   int jresult ;
22967   int result;
22968
22969   result = (int)Dali::Vector< float >::BaseType;
22970   jresult = (int)result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
22976   void * jresult ;
22977   Dali::Vector< float > *result = 0 ;
22978
22979   {
22980     try {
22981       result = (Dali::Vector< float > *)new Dali::Vector< float >();
22982     } CALL_CATCH_EXCEPTION(0);
22983   }
22984
22985   jresult = (void *)result;
22986   return jresult;
22987 }
22988
22989
22990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
22991   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22992
22993   arg1 = (Dali::Vector< float > *)jarg1;
22994   {
22995     try {
22996       delete arg1;
22997     } CALL_CATCH_EXCEPTION();
22998   }
22999
23000 }
23001
23002
23003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
23004   void * jresult ;
23005   Dali::Vector< float > *arg1 = 0 ;
23006   Dali::Vector< float > *result = 0 ;
23007
23008   arg1 = (Dali::Vector< float > *)jarg1;
23009   if (!arg1) {
23010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
23011     return 0;
23012   }
23013   {
23014     try {
23015       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
23016     } CALL_CATCH_EXCEPTION(0);
23017   }
23018
23019   jresult = (void *)result;
23020   return jresult;
23021 }
23022
23023
23024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
23025   void * jresult ;
23026   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23027   Dali::Vector< float > *arg2 = 0 ;
23028   Dali::Vector< float > *result = 0 ;
23029
23030   arg1 = (Dali::Vector< float > *)jarg1;
23031   arg2 = (Dali::Vector< float > *)jarg2;
23032   if (!arg2) {
23033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
23034     return 0;
23035   }
23036   {
23037     try {
23038       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
23039     } CALL_CATCH_EXCEPTION(0);
23040   }
23041
23042   jresult = (void *)result;
23043   return jresult;
23044 }
23045
23046
23047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
23048   void * jresult ;
23049   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23050   Dali::Vector< float >::Iterator result;
23051
23052   arg1 = (Dali::Vector< float > *)jarg1;
23053   {
23054     try {
23055       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
23056     } CALL_CATCH_EXCEPTION(0);
23057   }
23058
23059   jresult = (void *)result;
23060   return jresult;
23061 }
23062
23063
23064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
23065   void * jresult ;
23066   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23067   Dali::Vector< float >::Iterator result;
23068
23069   arg1 = (Dali::Vector< float > *)jarg1;
23070   {
23071     try {
23072       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
23073     } CALL_CATCH_EXCEPTION(0);
23074   }
23075
23076   jresult = (void *)result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23082   void * jresult ;
23083   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23084   Dali::Vector< float >::SizeType arg2 ;
23085   Dali::Vector< float >::ItemType *result = 0 ;
23086
23087   arg1 = (Dali::Vector< float > *)jarg1;
23088   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23089   {
23090     try {
23091       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
23092     } CALL_CATCH_EXCEPTION(0);
23093   }
23094
23095   jresult = (void *)result;
23096   return jresult;
23097 }
23098
23099
23100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
23101   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23102   Dali::Vector< float >::ItemType *arg2 = 0 ;
23103   Dali::Vector< float >::ItemType temp2 ;
23104
23105   arg1 = (Dali::Vector< float > *)jarg1;
23106   temp2 = (Dali::Vector< float >::ItemType)jarg2;
23107   arg2 = &temp2;
23108   {
23109     try {
23110       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
23111     } CALL_CATCH_EXCEPTION();
23112   }
23113
23114 }
23115
23116
23117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
23118   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23119   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23120   Dali::Vector< float >::ItemType *arg3 = 0 ;
23121   Dali::Vector< float >::ItemType temp3 ;
23122
23123   arg1 = (Dali::Vector< float > *)jarg1;
23124   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23125   temp3 = (Dali::Vector< float >::ItemType)jarg3;
23126   arg3 = &temp3;
23127   {
23128     try {
23129       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
23130     } CALL_CATCH_EXCEPTION();
23131   }
23132
23133 }
23134
23135
23136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
23137   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23138   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23139   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
23140   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
23141
23142   arg1 = (Dali::Vector< float > *)jarg1;
23143   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23144   arg3 = (Dali::Vector< float >::Iterator)jarg3;
23145   arg4 = (Dali::Vector< float >::Iterator)jarg4;
23146   {
23147     try {
23148       (arg1)->Insert(arg2,arg3,arg4);
23149     } CALL_CATCH_EXCEPTION();
23150   }
23151
23152 }
23153
23154
23155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
23156   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23157   Dali::Vector< float >::SizeType arg2 ;
23158
23159   arg1 = (Dali::Vector< float > *)jarg1;
23160   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23161   {
23162     try {
23163       (arg1)->Reserve(arg2);
23164     } CALL_CATCH_EXCEPTION();
23165   }
23166
23167 }
23168
23169 //// ========================= end of part 2 =============================
23170
23171 //// ========================== start part 3 ===============================
23172
23173
23174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23175   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23176   Dali::Vector< float >::SizeType arg2 ;
23177
23178   arg1 = (Dali::Vector< float > *)jarg1;
23179   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23180   {
23181     try {
23182       (arg1)->Resize(arg2);
23183     } CALL_CATCH_EXCEPTION();
23184   }
23185
23186 }
23187
23188
23189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
23190   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23191   Dali::Vector< float >::SizeType arg2 ;
23192   Dali::Vector< float >::ItemType *arg3 = 0 ;
23193   Dali::Vector< float >::ItemType temp3 ;
23194
23195   arg1 = (Dali::Vector< float > *)jarg1;
23196   arg2 = (Dali::Vector< float >::SizeType)jarg2;
23197   temp3 = (Dali::Vector< float >::ItemType)jarg3;
23198   arg3 = &temp3;
23199   {
23200     try {
23201       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
23202     } CALL_CATCH_EXCEPTION();
23203   }
23204
23205 }
23206
23207
23208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
23209   void * jresult ;
23210   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23211   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23212   Dali::Vector< float >::Iterator result;
23213
23214   arg1 = (Dali::Vector< float > *)jarg1;
23215   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23216   {
23217     try {
23218       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
23219     } CALL_CATCH_EXCEPTION(0);
23220   }
23221
23222   jresult = (void *)result;
23223   return jresult;
23224 }
23225
23226
23227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23228   void * jresult ;
23229   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23230   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23231   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
23232   Dali::Vector< float >::Iterator result;
23233
23234   arg1 = (Dali::Vector< float > *)jarg1;
23235   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23236   arg3 = (Dali::Vector< float >::Iterator)jarg3;
23237   {
23238     try {
23239       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
23240     } CALL_CATCH_EXCEPTION(0);
23241   }
23242
23243   jresult = (void *)result;
23244   return jresult;
23245 }
23246
23247
23248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
23249   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23250   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
23251
23252   arg1 = (Dali::Vector< float > *)jarg1;
23253   arg2 = (Dali::Vector< float >::Iterator)jarg2;
23254   {
23255     try {
23256       (arg1)->Remove(arg2);
23257     } CALL_CATCH_EXCEPTION();
23258   }
23259
23260 }
23261
23262
23263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
23264   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23265   Dali::Vector< float > *arg2 = 0 ;
23266
23267   arg1 = (Dali::Vector< float > *)jarg1;
23268   arg2 = (Dali::Vector< float > *)jarg2;
23269   if (!arg2) {
23270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
23271     return ;
23272   }
23273   {
23274     try {
23275       (arg1)->Swap(*arg2);
23276     } CALL_CATCH_EXCEPTION();
23277   }
23278
23279 }
23280
23281
23282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
23283   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23284
23285   arg1 = (Dali::Vector< float > *)jarg1;
23286   {
23287     try {
23288       (arg1)->Clear();
23289     } CALL_CATCH_EXCEPTION();
23290   }
23291
23292 }
23293
23294
23295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
23296   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
23297
23298   arg1 = (Dali::Vector< float > *)jarg1;
23299   {
23300     try {
23301       (arg1)->Release();
23302     } CALL_CATCH_EXCEPTION();
23303   }
23304
23305 }
23306
23307
23308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
23309   int jresult ;
23310   int result;
23311
23312   result = (int)Dali::Vector< unsigned char >::BaseType;
23313   jresult = (int)result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
23319   void * jresult ;
23320   Dali::Vector< unsigned char > *result = 0 ;
23321
23322   {
23323     try {
23324       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
23325     } CALL_CATCH_EXCEPTION(0);
23326   }
23327
23328   jresult = (void *)result;
23329   return jresult;
23330 }
23331
23332
23333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
23334   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23335
23336   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23337   {
23338     try {
23339       delete arg1;
23340     } CALL_CATCH_EXCEPTION();
23341   }
23342
23343 }
23344
23345
23346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
23347   void * jresult ;
23348   Dali::Vector< unsigned char > *arg1 = 0 ;
23349   Dali::Vector< unsigned char > *result = 0 ;
23350
23351   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23352   if (!arg1) {
23353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
23354     return 0;
23355   }
23356   {
23357     try {
23358       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
23359     } CALL_CATCH_EXCEPTION(0);
23360   }
23361
23362   jresult = (void *)result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
23368   void * jresult ;
23369   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23370   Dali::Vector< unsigned char > *arg2 = 0 ;
23371   Dali::Vector< unsigned char > *result = 0 ;
23372
23373   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23374   arg2 = (Dali::Vector< unsigned char > *)jarg2;
23375   if (!arg2) {
23376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
23377     return 0;
23378   }
23379   {
23380     try {
23381       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
23382     } CALL_CATCH_EXCEPTION(0);
23383   }
23384
23385   jresult = (void *)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
23391   void * jresult ;
23392   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23393   Dali::Vector< unsigned char >::Iterator result;
23394
23395   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23396   {
23397     try {
23398       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
23399     } CALL_CATCH_EXCEPTION(0);
23400   }
23401
23402   jresult = (void *)result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
23408   void * jresult ;
23409   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23410   Dali::Vector< unsigned char >::Iterator result;
23411
23412   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23413   {
23414     try {
23415       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
23416     } CALL_CATCH_EXCEPTION(0);
23417   }
23418
23419   jresult = (void *)result;
23420   return jresult;
23421 }
23422
23423
23424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23425   void * jresult ;
23426   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23427   Dali::Vector< unsigned char >::SizeType arg2 ;
23428   Dali::Vector< unsigned char >::ItemType *result = 0 ;
23429
23430   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23431   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23432   {
23433     try {
23434       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
23435     } CALL_CATCH_EXCEPTION(0);
23436   }
23437
23438   jresult = (void *)result;
23439   return jresult;
23440 }
23441
23442
23443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
23444   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23445   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
23446   Dali::Vector< unsigned char >::ItemType temp2 ;
23447
23448   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23449   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
23450   arg2 = &temp2;
23451   {
23452     try {
23453       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
23454     } CALL_CATCH_EXCEPTION();
23455   }
23456
23457 }
23458
23459
23460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
23461   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23462   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23463   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
23464   Dali::Vector< unsigned char >::ItemType temp3 ;
23465
23466   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23467   arg2 = jarg2;
23468   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
23469   arg3 = &temp3;
23470   {
23471     try {
23472       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
23473     } CALL_CATCH_EXCEPTION();
23474   }
23475
23476
23477
23478 }
23479
23480
23481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
23482   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23483   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23484   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23485   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23486
23487   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23488   arg2 = jarg2;
23489   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
23490   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
23491   {
23492     try {
23493       (arg1)->Insert(arg2,arg3,arg4);
23494     } CALL_CATCH_EXCEPTION();
23495   }
23496
23497
23498
23499 }
23500
23501
23502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
23503   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23504   Dali::Vector< unsigned char >::SizeType arg2 ;
23505
23506   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23507   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23508   {
23509     try {
23510       (arg1)->Reserve(arg2);
23511     } CALL_CATCH_EXCEPTION();
23512   }
23513
23514 }
23515
23516
23517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23518   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23519   Dali::Vector< unsigned char >::SizeType arg2 ;
23520
23521   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23522   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23523   {
23524     try {
23525       (arg1)->Resize(arg2);
23526     } CALL_CATCH_EXCEPTION();
23527   }
23528
23529 }
23530
23531
23532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
23533   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23534   Dali::Vector< unsigned char >::SizeType arg2 ;
23535   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
23536   Dali::Vector< unsigned char >::ItemType temp3 ;
23537
23538   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23539   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23540   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
23541   arg3 = &temp3;
23542   {
23543     try {
23544       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
23545     } CALL_CATCH_EXCEPTION();
23546   }
23547
23548 }
23549
23550
23551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
23552   void * jresult ;
23553   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23554   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23555   Dali::Vector< unsigned char >::Iterator result;
23556
23557   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23558   arg2 = jarg2;
23559   {
23560     try {
23561       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
23562     } CALL_CATCH_EXCEPTION(0);
23563   }
23564
23565   jresult = (void *)result;
23566
23567
23568   return jresult;
23569 }
23570
23571
23572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
23573   void * jresult ;
23574   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23575   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23576   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23577   Dali::Vector< unsigned char >::Iterator result;
23578
23579   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23580   arg2 = jarg2;
23581   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
23582   {
23583     try {
23584       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
23585     } CALL_CATCH_EXCEPTION(0);
23586   }
23587
23588   jresult = (void *)result;
23589
23590
23591   return jresult;
23592 }
23593
23594
23595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
23596   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23597   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23598
23599   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23600   arg2 = jarg2;
23601   {
23602     try {
23603       (arg1)->Remove(arg2);
23604     } CALL_CATCH_EXCEPTION();
23605   }
23606
23607
23608
23609 }
23610
23611
23612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
23613   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23614   Dali::Vector< unsigned char > *arg2 = 0 ;
23615
23616   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23617   arg2 = (Dali::Vector< unsigned char > *)jarg2;
23618   if (!arg2) {
23619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
23620     return ;
23621   }
23622   {
23623     try {
23624       (arg1)->Swap(*arg2);
23625     } CALL_CATCH_EXCEPTION();
23626   }
23627
23628 }
23629
23630
23631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
23632   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23633
23634   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23635   {
23636     try {
23637       (arg1)->Clear();
23638     } CALL_CATCH_EXCEPTION();
23639   }
23640
23641 }
23642
23643
23644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
23645   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23646
23647   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23648   {
23649     try {
23650       (arg1)->Release();
23651     } CALL_CATCH_EXCEPTION();
23652   }
23653
23654 }
23655
23656
23657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
23658   int jresult ;
23659   int result;
23660
23661   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
23662   jresult = (int)result;
23663   return jresult;
23664 }
23665
23666
23667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
23668   void * jresult ;
23669   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23670
23671   {
23672     try {
23673       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
23674     } CALL_CATCH_EXCEPTION(0);
23675   }
23676
23677   jresult = (void *)result;
23678   return jresult;
23679 }
23680
23681
23682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
23683   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23684
23685   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23686   {
23687     try {
23688       delete arg1;
23689     } CALL_CATCH_EXCEPTION();
23690   }
23691
23692 }
23693
23694
23695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
23696   void * jresult ;
23697   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
23698   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23699
23700   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23701   if (!arg1) {
23702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
23703     return 0;
23704   }
23705   {
23706     try {
23707       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
23708     } CALL_CATCH_EXCEPTION(0);
23709   }
23710
23711   jresult = (void *)result;
23712   return jresult;
23713 }
23714
23715
23716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
23717   void * jresult ;
23718   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23719   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
23720   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23721
23722   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23723   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
23724   if (!arg2) {
23725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
23726     return 0;
23727   }
23728   {
23729     try {
23730       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
23731     } CALL_CATCH_EXCEPTION(0);
23732   }
23733
23734   jresult = (void *)result;
23735   return jresult;
23736 }
23737
23738
23739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
23740   void * jresult ;
23741   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23742   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23743
23744   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23745   {
23746     try {
23747       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
23748     } CALL_CATCH_EXCEPTION(0);
23749   }
23750
23751   jresult = (void *)result;
23752   return jresult;
23753 }
23754
23755
23756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
23757   void * jresult ;
23758   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23759   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23760
23761   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23762   {
23763     try {
23764       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
23765     } CALL_CATCH_EXCEPTION(0);
23766   }
23767
23768   jresult = (void *)result;
23769   return jresult;
23770 }
23771
23772
23773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23774   void * jresult ;
23775   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23776   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23777   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
23778
23779   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23780   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23781   {
23782     try {
23783       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
23784     } CALL_CATCH_EXCEPTION(0);
23785   }
23786
23787   jresult = (void *)result;
23788   return jresult;
23789 }
23790
23791
23792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
23793   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23794   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
23795
23796   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23797   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
23798   if (!arg2) {
23799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23800     return ;
23801   }
23802   {
23803     try {
23804       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
23805     } CALL_CATCH_EXCEPTION();
23806   }
23807
23808 }
23809
23810
23811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23812   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23813   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23814   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
23815
23816   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23817   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23818   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
23819   if (!arg3) {
23820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23821     return ;
23822   }
23823   {
23824     try {
23825       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
23826     } CALL_CATCH_EXCEPTION();
23827   }
23828
23829 }
23830
23831
23832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
23833   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23834   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23835   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23836   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23837
23838   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23839   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23840   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
23841   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
23842   {
23843     try {
23844       (arg1)->Insert(arg2,arg3,arg4);
23845     } CALL_CATCH_EXCEPTION();
23846   }
23847
23848 }
23849
23850
23851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
23852   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23853   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23854
23855   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23856   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23857   {
23858     try {
23859       (arg1)->Reserve(arg2);
23860     } CALL_CATCH_EXCEPTION();
23861   }
23862
23863 }
23864
23865
23866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23867   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23868   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23869
23870   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23871   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23872   {
23873     try {
23874       (arg1)->Resize(arg2);
23875     } CALL_CATCH_EXCEPTION();
23876   }
23877
23878 }
23879
23880
23881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
23882   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23883   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23884   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
23885
23886   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23887   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23888   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
23889   if (!arg3) {
23890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23891     return ;
23892   }
23893   {
23894     try {
23895       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
23896     } CALL_CATCH_EXCEPTION();
23897   }
23898
23899 }
23900
23901
23902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
23903   void * jresult ;
23904   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23905   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23906   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23907
23908   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23909   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23910   {
23911     try {
23912       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
23913     } CALL_CATCH_EXCEPTION(0);
23914   }
23915
23916   jresult = (void *)result;
23917   return jresult;
23918 }
23919
23920
23921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23922   void * jresult ;
23923   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23924   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23925   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23926   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23927
23928   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23929   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23930   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
23931   {
23932     try {
23933       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
23934     } CALL_CATCH_EXCEPTION(0);
23935   }
23936
23937   jresult = (void *)result;
23938   return jresult;
23939 }
23940
23941
23942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
23943   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23944   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23945
23946   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23947   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23948   {
23949     try {
23950       (arg1)->Remove(arg2);
23951     } CALL_CATCH_EXCEPTION();
23952   }
23953
23954 }
23955
23956
23957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
23958   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23959   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
23960
23961   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23962   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
23963   if (!arg2) {
23964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
23965     return ;
23966   }
23967   {
23968     try {
23969       (arg1)->Swap(*arg2);
23970     } CALL_CATCH_EXCEPTION();
23971   }
23972
23973 }
23974
23975
23976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
23977   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23978
23979   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23980   {
23981     try {
23982       (arg1)->Clear();
23983     } CALL_CATCH_EXCEPTION();
23984   }
23985
23986 }
23987
23988
23989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
23990   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23991
23992   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23993   {
23994     try {
23995       (arg1)->Release();
23996     } CALL_CATCH_EXCEPTION();
23997   }
23998
23999 }
24000
24001
24002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
24003   void * jresult ;
24004   Dali::Signal< void () > *result = 0 ;
24005
24006   {
24007     try {
24008       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
24009     } CALL_CATCH_EXCEPTION(0);
24010   }
24011
24012   jresult = (void *)result;
24013   return jresult;
24014 }
24015
24016
24017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
24018   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24019
24020   arg1 = (Dali::Signal< void () > *)jarg1;
24021   {
24022     try {
24023       delete arg1;
24024     } CALL_CATCH_EXCEPTION();
24025   }
24026
24027 }
24028
24029
24030 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
24031   bool jresult ;
24032   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24033   bool result;
24034
24035   arg1 = (Dali::Signal< void () > *)jarg1;
24036   {
24037     try {
24038       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
24039     } CALL_CATCH_EXCEPTION(0);
24040   }
24041
24042   jresult = result;
24043   return jresult;
24044 }
24045
24046
24047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
24048   unsigned long jresult ;
24049   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24050   std::size_t result;
24051
24052   arg1 = (Dali::Signal< void () > *)jarg1;
24053   {
24054     try {
24055       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
24056     } CALL_CATCH_EXCEPTION(0);
24057   }
24058
24059   jresult = (unsigned long)result;
24060   return jresult;
24061 }
24062
24063
24064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
24065   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24066   void (*arg2)() = (void (*)()) 0 ;
24067
24068   arg1 = (Dali::Signal< void () > *)jarg1;
24069   arg2 = (void (*)())jarg2;
24070   {
24071     try {
24072       (arg1)->Connect(arg2);
24073     } CALL_CATCH_EXCEPTION();
24074   }
24075
24076 }
24077
24078
24079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
24080   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24081   void (*arg2)() = (void (*)()) 0 ;
24082
24083   arg1 = (Dali::Signal< void () > *)jarg1;
24084   arg2 = (void (*)())jarg2;
24085   {
24086     try {
24087       (arg1)->Disconnect(arg2);
24088     } CALL_CATCH_EXCEPTION();
24089   }
24090
24091 }
24092
24093
24094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
24095   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24096   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
24097   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
24098
24099   arg1 = (Dali::Signal< void () > *)jarg1;
24100   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
24101   arg3 = (Dali::FunctorDelegate *)jarg3;
24102   {
24103     try {
24104       (arg1)->Connect(arg2,arg3);
24105     } CALL_CATCH_EXCEPTION();
24106   }
24107
24108 }
24109
24110
24111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
24112   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
24113
24114   arg1 = (Dali::Signal< void () > *)jarg1;
24115   {
24116     try {
24117       (arg1)->Emit();
24118     } CALL_CATCH_EXCEPTION();
24119   }
24120
24121 }
24122
24123
24124 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
24125   bool jresult ;
24126   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24127   bool result;
24128
24129   arg1 = (Dali::Signal< void (float) > *)jarg1;
24130   {
24131     try {
24132       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
24133     } CALL_CATCH_EXCEPTION(0);
24134   }
24135
24136   jresult = result;
24137   return jresult;
24138 }
24139
24140
24141 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
24142   unsigned long jresult ;
24143   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24144   std::size_t result;
24145
24146   arg1 = (Dali::Signal< void (float) > *)jarg1;
24147   {
24148     try {
24149       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
24150     } CALL_CATCH_EXCEPTION(0);
24151   }
24152
24153   jresult = (unsigned long)result;
24154   return jresult;
24155 }
24156
24157
24158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
24159   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24160   void (*arg2)(float) = (void (*)(float)) 0 ;
24161
24162   arg1 = (Dali::Signal< void (float) > *)jarg1;
24163   arg2 = (void (*)(float))jarg2;
24164   {
24165     try {
24166       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
24167     } CALL_CATCH_EXCEPTION();
24168   }
24169
24170 }
24171
24172
24173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
24174   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24175   void (*arg2)(float) = (void (*)(float)) 0 ;
24176
24177   arg1 = (Dali::Signal< void (float) > *)jarg1;
24178   arg2 = (void (*)(float))jarg2;
24179   {
24180     try {
24181       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
24182     } CALL_CATCH_EXCEPTION();
24183   }
24184
24185 }
24186
24187
24188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
24189   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24190   float arg2 ;
24191
24192   arg1 = (Dali::Signal< void (float) > *)jarg1;
24193   arg2 = (float)jarg2;
24194   {
24195     try {
24196       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
24197     } CALL_CATCH_EXCEPTION();
24198   }
24199
24200 }
24201
24202
24203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
24204   void * jresult ;
24205   Dali::Signal< void (float) > *result = 0 ;
24206
24207   {
24208     try {
24209       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
24210     } CALL_CATCH_EXCEPTION(0);
24211   }
24212
24213   jresult = (void *)result;
24214   return jresult;
24215 }
24216
24217
24218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
24219   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
24220
24221   arg1 = (Dali::Signal< void (float) > *)jarg1;
24222   {
24223     try {
24224       delete arg1;
24225     } CALL_CATCH_EXCEPTION();
24226   }
24227
24228 }
24229
24230
24231 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
24232   bool jresult ;
24233   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24234   bool result;
24235
24236   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24237   {
24238     try {
24239       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
24240     } CALL_CATCH_EXCEPTION(0);
24241   }
24242
24243   jresult = result;
24244   return jresult;
24245 }
24246
24247
24248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
24249   unsigned long jresult ;
24250   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24251   std::size_t result;
24252
24253   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24254   {
24255     try {
24256       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
24257     } CALL_CATCH_EXCEPTION(0);
24258   }
24259
24260   jresult = (unsigned long)result;
24261   return jresult;
24262 }
24263
24264
24265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
24266   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24267   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
24268
24269   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24270   arg2 = (void (*)(Dali::BaseHandle))jarg2;
24271   {
24272     try {
24273       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
24274     } CALL_CATCH_EXCEPTION();
24275   }
24276
24277 }
24278
24279
24280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
24281   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24282   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
24283
24284   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24285   arg2 = (void (*)(Dali::BaseHandle))jarg2;
24286   {
24287     try {
24288       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
24289     } CALL_CATCH_EXCEPTION();
24290   }
24291
24292 }
24293
24294
24295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
24296   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24297   Dali::BaseHandle arg2 ;
24298   Dali::BaseHandle *argp2 ;
24299
24300   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24301   argp2 = (Dali::BaseHandle *)jarg2;
24302   if (!argp2) {
24303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24304     return ;
24305   }
24306   arg2 = *argp2;
24307   {
24308     try {
24309       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
24310     } CALL_CATCH_EXCEPTION();
24311   }
24312
24313 }
24314
24315
24316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
24317   void * jresult ;
24318   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
24319
24320   {
24321     try {
24322       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
24323     } CALL_CATCH_EXCEPTION(0);
24324   }
24325
24326   jresult = (void *)result;
24327   return jresult;
24328 }
24329
24330
24331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
24332   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
24333
24334   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
24335   {
24336     try {
24337       delete arg1;
24338     } CALL_CATCH_EXCEPTION();
24339   }
24340
24341 }
24342
24343
24344 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
24345   bool jresult ;
24346   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24347   bool result;
24348
24349   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24350   {
24351     try {
24352       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
24353     } CALL_CATCH_EXCEPTION(0);
24354   }
24355
24356   jresult = result;
24357   return jresult;
24358 }
24359
24360
24361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
24362   unsigned long jresult ;
24363   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24364   std::size_t result;
24365
24366   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24367   {
24368     try {
24369       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
24370     } CALL_CATCH_EXCEPTION(0);
24371   }
24372
24373   jresult = (unsigned long)result;
24374   return jresult;
24375 }
24376
24377
24378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
24379   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24380   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
24381
24382   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24383   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
24384   {
24385     try {
24386       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
24387     } CALL_CATCH_EXCEPTION();
24388   }
24389
24390 }
24391
24392
24393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
24394   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24395   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
24396
24397   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24398   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
24399   {
24400     try {
24401       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
24402     } CALL_CATCH_EXCEPTION();
24403   }
24404
24405 }
24406
24407
24408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
24409   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24410   Dali::PropertyNotification *arg2 = 0 ;
24411
24412   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24413   arg2 = (Dali::PropertyNotification *)jarg2;
24414   if (!arg2) {
24415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
24416     return ;
24417   }
24418   {
24419     try {
24420       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
24421     } CALL_CATCH_EXCEPTION();
24422   }
24423
24424 }
24425
24426
24427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
24428   void * jresult ;
24429   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
24430
24431   {
24432     try {
24433       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
24434     } CALL_CATCH_EXCEPTION(0);
24435   }
24436
24437   jresult = (void *)result;
24438   return jresult;
24439 }
24440
24441
24442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
24443   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24444
24445   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24446   {
24447     try {
24448       delete arg1;
24449     } CALL_CATCH_EXCEPTION();
24450   }
24451
24452 }
24453
24454
24455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
24456   void * jresult ;
24457   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
24458
24459   {
24460     try {
24461       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
24462     } CALL_CATCH_EXCEPTION(0);
24463   }
24464
24465   jresult = (void *)result;
24466   return jresult;
24467 }
24468
24469
24470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
24471   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
24472
24473   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
24474   {
24475     try {
24476       delete arg1;
24477     } CALL_CATCH_EXCEPTION();
24478   }
24479
24480 }
24481
24482
24483 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
24484   bool jresult ;
24485   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24486   bool result;
24487
24488   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24489   {
24490     try {
24491       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);
24492     } CALL_CATCH_EXCEPTION(0);
24493   }
24494
24495   jresult = result;
24496   return jresult;
24497 }
24498
24499
24500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24501   unsigned long jresult ;
24502   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24503   std::size_t result;
24504
24505   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24506   {
24507     try {
24508       result = Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
24509     } CALL_CATCH_EXCEPTION(0);
24510   }
24511
24512   jresult = (unsigned long)result;
24513   return jresult;
24514 }
24515
24516
24517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24518   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24519   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
24520
24521   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24522   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
24523   {
24524     try {
24525       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24526     } CALL_CATCH_EXCEPTION();
24527   }
24528
24529 }
24530
24531
24532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24533   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24534   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
24535
24536   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24537   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
24538   {
24539     try {
24540       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24541     } CALL_CATCH_EXCEPTION();
24542   }
24543
24544 }
24545
24546
24547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
24548   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24549   Dali::Actor arg2 ;
24550   Dali::LongPressGesture *arg3 = 0 ;
24551   Dali::Actor *argp2 ;
24552
24553   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24554   argp2 = (Dali::Actor *)jarg2;
24555   if (!argp2) {
24556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24557     return ;
24558   }
24559   arg2 = *argp2;
24560   arg3 = (Dali::LongPressGesture *)jarg3;
24561   if (!arg3) {
24562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
24563     return ;
24564   }
24565   {
24566     try {
24567       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
24568     } CALL_CATCH_EXCEPTION();
24569   }
24570
24571 }
24572
24573
24574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
24575   void * jresult ;
24576   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
24577
24578   {
24579     try {
24580       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
24581     } CALL_CATCH_EXCEPTION(0);
24582   }
24583
24584   jresult = (void *)result;
24585   return jresult;
24586 }
24587
24588
24589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
24590   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24591
24592   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24593   {
24594     try {
24595       delete arg1;
24596     } CALL_CATCH_EXCEPTION();
24597   }
24598
24599 }
24600
24601
24602 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
24603   bool jresult ;
24604   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24605   bool result;
24606
24607   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24608   {
24609     try {
24610       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
24611     } CALL_CATCH_EXCEPTION(0);
24612   }
24613
24614   jresult = result;
24615   return jresult;
24616 }
24617
24618
24619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
24620   unsigned long jresult ;
24621   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24622   std::size_t result;
24623
24624   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24625   {
24626     try {
24627       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
24628     } CALL_CATCH_EXCEPTION(0);
24629   }
24630
24631   jresult = (unsigned long)result;
24632   return jresult;
24633 }
24634
24635
24636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
24637   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24638   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
24639
24640   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24641   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
24642   {
24643     try {
24644       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24645     } CALL_CATCH_EXCEPTION();
24646   }
24647
24648 }
24649
24650
24651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
24652   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24653   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
24654
24655   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24656   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
24657   {
24658     try {
24659       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24660     } CALL_CATCH_EXCEPTION();
24661   }
24662
24663 }
24664
24665
24666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
24667   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24668   Dali::KeyEvent *arg2 = 0 ;
24669
24670   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24671   arg2 = (Dali::KeyEvent *)jarg2;
24672   if (!arg2) {
24673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24674     return ;
24675   }
24676   {
24677     try {
24678       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
24679     } CALL_CATCH_EXCEPTION();
24680   }
24681
24682 }
24683
24684
24685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
24686   void * jresult ;
24687   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
24688
24689   {
24690     try {
24691       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
24692     } CALL_CATCH_EXCEPTION(0);
24693   }
24694
24695   jresult = (void *)result;
24696   return jresult;
24697 }
24698
24699
24700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
24701   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24702
24703   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24704   {
24705     try {
24706       delete arg1;
24707     } CALL_CATCH_EXCEPTION();
24708   }
24709
24710 }
24711
24712 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
24713   bool jresult ;
24714   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24715   bool result;
24716
24717   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24718   {
24719     try {
24720       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
24721     } CALL_CATCH_EXCEPTION(0);
24722   }
24723
24724   jresult = result;
24725   return jresult;
24726 }
24727
24728
24729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
24730   unsigned long jresult ;
24731   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24732   std::size_t result;
24733
24734   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24735   {
24736     try {
24737       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
24738     } CALL_CATCH_EXCEPTION(0);
24739   }
24740
24741   jresult = (unsigned long)result;
24742   return jresult;
24743 }
24744
24745
24746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
24747   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24748   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
24749
24750   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24751   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
24752   {
24753     try {
24754       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24755     } CALL_CATCH_EXCEPTION();
24756   }
24757
24758 }
24759
24760
24761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
24762   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24763   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
24764
24765   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24766   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
24767   {
24768     try {
24769       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24770     } CALL_CATCH_EXCEPTION();
24771   }
24772
24773 }
24774
24775
24776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
24777   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24778   Dali::WheelEvent *arg2 = 0 ;
24779
24780   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24781   arg2 = (Dali::WheelEvent *)jarg2;
24782   if (!arg2) {
24783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24784     return ;
24785   }
24786   {
24787     try {
24788       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
24789     } CALL_CATCH_EXCEPTION();
24790   }
24791
24792 }
24793
24794
24795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
24796   void * jresult ;
24797   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
24798
24799   {
24800     try {
24801       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
24802     } CALL_CATCH_EXCEPTION(0);
24803   }
24804
24805   jresult = (void *)result;
24806   return jresult;
24807 }
24808
24809
24810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
24811   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24812
24813   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24814   {
24815     try {
24816       delete arg1;
24817     } CALL_CATCH_EXCEPTION();
24818   }
24819
24820 }
24821
24822
24823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
24824   void * jresult ;
24825   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24826
24827   {
24828     try {
24829       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
24830     } CALL_CATCH_EXCEPTION(0);
24831   }
24832
24833   jresult = (void *)result;
24834   return jresult;
24835 }
24836
24837
24838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
24839   void * jresult ;
24840   Dali::Radian arg1 ;
24841   Dali::Radian arg2 ;
24842   Dali::Radian *argp1 ;
24843   Dali::Radian *argp2 ;
24844   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24845
24846   argp1 = (Dali::Radian *)jarg1;
24847   if (!argp1) {
24848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
24849     return 0;
24850   }
24851   arg1 = *argp1;
24852   argp2 = (Dali::Radian *)jarg2;
24853   if (!argp2) {
24854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
24855     return 0;
24856   }
24857   arg2 = *argp2;
24858   {
24859     try {
24860       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
24861     } CALL_CATCH_EXCEPTION(0);
24862   }
24863
24864   jresult = (void *)result;
24865   return jresult;
24866 }
24867
24868
24869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
24870   void * jresult ;
24871   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
24872   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24873
24874   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24875   if (!arg1) {
24876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
24877     return 0;
24878   }
24879   {
24880     try {
24881       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
24882     } CALL_CATCH_EXCEPTION(0);
24883   }
24884
24885   jresult = (void *)result;
24886   return jresult;
24887 }
24888
24889
24890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
24891   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24892   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
24893
24894   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24895   arg2 = (Dali::Radian *)jarg2;
24896   if (arg1) (arg1)->first = *arg2;
24897 }
24898
24899
24900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
24901   void * jresult ;
24902   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24903   Dali::Radian *result = 0 ;
24904
24905   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24906   result = (Dali::Radian *)& ((arg1)->first);
24907   jresult = (void *)result;
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
24913   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24914   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
24915
24916   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24917   arg2 = (Dali::Radian *)jarg2;
24918   if (arg1) (arg1)->second = *arg2;
24919 }
24920
24921
24922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
24923   void * jresult ;
24924   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24925   Dali::Radian *result = 0 ;
24926
24927   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24928   result = (Dali::Radian *)& ((arg1)->second);
24929   jresult = (void *)result;
24930   return jresult;
24931 }
24932
24933
24934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
24935   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24936
24937   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24938   {
24939     try {
24940       delete arg1;
24941     } CALL_CATCH_EXCEPTION();
24942   }
24943
24944 }
24945
24946
24947 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
24948   bool jresult ;
24949   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24950   bool result;
24951
24952   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24953   {
24954     try {
24955       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);
24956     } CALL_CATCH_EXCEPTION(0);
24957   }
24958
24959   jresult = result;
24960   return jresult;
24961 }
24962
24963
24964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24965   unsigned long jresult ;
24966   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24967   std::size_t result;
24968
24969   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24970   {
24971     try {
24972       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);
24973     } CALL_CATCH_EXCEPTION(0);
24974   }
24975
24976   jresult = (unsigned long)result;
24977   return jresult;
24978 }
24979
24980
24981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24982   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24983   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
24984
24985   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24986   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
24987   {
24988     try {
24989       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24990     } CALL_CATCH_EXCEPTION();
24991   }
24992
24993 }
24994
24995
24996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24997   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24998   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
24999
25000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
25001   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
25002   {
25003     try {
25004       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
25005     } CALL_CATCH_EXCEPTION();
25006   }
25007
25008 }
25009
25010
25011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
25012   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
25013   Dali::Actor arg2 ;
25014   Dali::PanGesture *arg3 = 0 ;
25015   Dali::Actor *argp2 ;
25016
25017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
25018   argp2 = (Dali::Actor *)jarg2;
25019   if (!argp2) {
25020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25021     return ;
25022   }
25023   arg2 = *argp2;
25024   arg3 = (Dali::PanGesture *)jarg3;
25025   if (!arg3) {
25026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
25027     return ;
25028   }
25029   {
25030     try {
25031       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
25032     } CALL_CATCH_EXCEPTION();
25033   }
25034
25035 }
25036
25037
25038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
25039   void * jresult ;
25040   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
25041
25042   {
25043     try {
25044       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
25045     } CALL_CATCH_EXCEPTION(0);
25046   }
25047
25048   jresult = (void *)result;
25049   return jresult;
25050 }
25051
25052
25053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
25054   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
25055
25056   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
25057   {
25058     try {
25059       delete arg1;
25060     } CALL_CATCH_EXCEPTION();
25061   }
25062
25063 }
25064
25065
25066 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
25067   bool jresult ;
25068   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25069   bool result;
25070
25071   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25072   {
25073     try {
25074       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);
25075     } CALL_CATCH_EXCEPTION(0);
25076   }
25077
25078   jresult = result;
25079   return jresult;
25080 }
25081
25082
25083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
25084   unsigned long jresult ;
25085   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25086   std::size_t result;
25087
25088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25089   {
25090     try {
25091       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);
25092     } CALL_CATCH_EXCEPTION(0);
25093   }
25094
25095   jresult = (unsigned long)result;
25096   return jresult;
25097 }
25098
25099
25100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
25101   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25102   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
25103
25104   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25105   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
25106   {
25107     try {
25108       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
25109     } CALL_CATCH_EXCEPTION();
25110   }
25111
25112 }
25113
25114
25115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
25116   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25117   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
25118
25119   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25120   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
25121   {
25122     try {
25123       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
25124     } CALL_CATCH_EXCEPTION();
25125   }
25126
25127 }
25128
25129
25130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
25131   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25132   Dali::Actor arg2 ;
25133   Dali::PinchGesture *arg3 = 0 ;
25134   Dali::Actor *argp2 ;
25135
25136   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25137   argp2 = (Dali::Actor *)jarg2;
25138   if (!argp2) {
25139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25140     return ;
25141   }
25142   arg2 = *argp2;
25143   arg3 = (Dali::PinchGesture *)jarg3;
25144   if (!arg3) {
25145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
25146     return ;
25147   }
25148   {
25149     try {
25150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
25151     } CALL_CATCH_EXCEPTION();
25152   }
25153
25154 }
25155
25156
25157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
25158   void * jresult ;
25159   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
25160
25161   {
25162     try {
25163       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
25164     } CALL_CATCH_EXCEPTION(0);
25165   }
25166
25167   jresult = (void *)result;
25168   return jresult;
25169 }
25170
25171
25172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
25173   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
25174
25175   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
25176   {
25177     try {
25178       delete arg1;
25179     } CALL_CATCH_EXCEPTION();
25180   }
25181
25182 }
25183
25184
25185 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
25186   bool jresult ;
25187   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25188   bool result;
25189
25190   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25191   {
25192     try {
25193       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);
25194     } CALL_CATCH_EXCEPTION(0);
25195   }
25196
25197   jresult = result;
25198   return jresult;
25199 }
25200
25201
25202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
25203   unsigned long jresult ;
25204   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25205   std::size_t result;
25206
25207   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25208   {
25209     try {
25210       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);
25211     } CALL_CATCH_EXCEPTION(0);
25212   }
25213
25214   jresult = (unsigned long)result;
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
25220   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25221   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
25222
25223   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25224   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
25225   {
25226     try {
25227       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
25228     } CALL_CATCH_EXCEPTION();
25229   }
25230
25231 }
25232
25233
25234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
25235   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25236   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
25237
25238   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25239   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
25240   {
25241     try {
25242       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
25243     } CALL_CATCH_EXCEPTION();
25244   }
25245
25246 }
25247
25248
25249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
25250   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25251   Dali::Actor arg2 ;
25252   Dali::TapGesture *arg3 = 0 ;
25253   Dali::Actor *argp2 ;
25254
25255   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25256   argp2 = (Dali::Actor *)jarg2;
25257   if (!argp2) {
25258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25259     return ;
25260   }
25261   arg2 = *argp2;
25262   arg3 = (Dali::TapGesture *)jarg3;
25263   if (!arg3) {
25264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
25265     return ;
25266   }
25267   {
25268     try {
25269       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
25270     } CALL_CATCH_EXCEPTION();
25271   }
25272
25273 }
25274
25275
25276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
25277   void * jresult ;
25278   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
25279
25280   {
25281     try {
25282       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
25283     } CALL_CATCH_EXCEPTION(0);
25284   }
25285
25286   jresult = (void *)result;
25287   return jresult;
25288 }
25289
25290
25291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
25292   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
25293
25294   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
25295   {
25296     try {
25297       delete arg1;
25298     } CALL_CATCH_EXCEPTION();
25299   }
25300
25301 }
25302
25303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
25304   unsigned long jresult ;
25305   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25306   std::size_t result = 0;
25307
25308   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25309   {
25310     try {
25311       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);
25312     }CALL_CATCH_EXCEPTION(0);
25313   }
25314   jresult = (unsigned long)result;
25315   return jresult;
25316 }
25317
25318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
25319   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25320   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
25321
25322   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25323   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
25324   {
25325     try {
25326       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
25327     } CALL_CATCH_EXCEPTION();
25328   }
25329 }
25330
25331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
25332   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25333   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
25334
25335   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25336   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
25337   {
25338     try {
25339       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
25340     } CALL_CATCH_EXCEPTION();
25341   }
25342 }
25343
25344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
25345   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25346   Dali::Actor arg2 ;
25347   //bool arg3 ;
25348   Dali::LayoutDirection::Type arg4 ;
25349   Dali::Actor *argp2 ;
25350
25351   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25352   argp2 = (Dali::Actor *)jarg2;
25353   if (!argp2) {
25354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25355     return ;
25356   }
25357   arg2 = *argp2;
25358   //arg3 = jarg3 ? true : false;
25359   arg4 = (Dali::LayoutDirection::Type)jarg4;
25360   {
25361     try {
25362       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
25363     } CALL_CATCH_EXCEPTION();
25364   }
25365 }
25366
25367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
25368   void * jresult ;
25369   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
25370
25371   {
25372     try {
25373       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
25374     } CALL_CATCH_EXCEPTION(0);
25375   }
25376   jresult = (void *)result;
25377   return jresult;
25378 }
25379
25380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
25381   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
25382
25383   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
25384   {
25385     try {
25386       delete arg1;
25387     } CALL_CATCH_EXCEPTION();
25388   }
25389 }
25390
25391
25392 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) {
25393   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
25394   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
25395   if (director) {
25396     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);
25397   }
25398 }
25399
25400
25401 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) {
25402   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
25403   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
25404   if (director) {
25405     director->swig_connect_director(callback0, callback1, callback2);
25406   }
25407 }
25408
25409
25410 //// ========================= end of part 3 =============================
25411
25412 //// ========================== start part 4 =============================
25413
25414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
25415   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
25416   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25417   if (director) {
25418     director->swig_connect_director(callback0);
25419   }
25420 }
25421
25422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect_with_return(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback1_t callback1) {
25423   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
25424   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25425   if (director) {
25426     director->swig_connect_director_with_return(callback1);
25427   }
25428 }
25429
25430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
25431   void * jresult ;
25432   Dali::FrameCallbackInterface *result = 0 ;
25433
25434   {
25435     try {
25436       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
25437     } CALL_CATCH_EXCEPTION(0);
25438   }
25439
25440   jresult = (void *)result;
25441   return jresult;
25442 }
25443
25444
25445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
25446   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
25447   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25448
25449   Dali::Stage *arg1 = (Dali::Stage *) 0;
25450   Dali::Actor *arg3 = 0;
25451
25452   arg1 = (Dali::Stage *)jarg1;
25453   arg3 = (Dali::Actor *)jarg3;
25454
25455   if(arg3 == nullptr)
25456   {
25457     DevelStage::AddFrameCallback( *arg1, *arg2, Dali::Actor() );
25458   }
25459   else
25460   {
25461     DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
25462   }
25463   return;
25464 }
25465
25466
25467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
25468
25469   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
25470   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25471
25472   Dali::Stage *arg1 = (Dali::Stage *) 0;
25473
25474   arg1 = (Dali::Stage *)jarg1;
25475
25476   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
25477   return;
25478 }
25479
25480
25481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
25482   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
25483   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
25484   if (director) {
25485     director->swig_connect_director(callback0);
25486   }
25487 }
25488
25489
25490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
25491   void * jresult ;
25492   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
25493
25494   {
25495     try {
25496       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
25497     } CALL_CATCH_EXCEPTION(0);
25498   }
25499
25500   jresult = (void *)result;
25501   return jresult;
25502 }
25503
25504
25505 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) {
25506   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
25507   if (director) {
25508     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
25509   }
25510 }
25511
25512
25513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
25514   void * jresult ;
25515   SwigDirector_WidgetImpl* result;
25516   {
25517     try {
25518       result = new SwigDirector_WidgetImpl();
25519     } CALL_CATCH_EXCEPTION(0);
25520   }
25521   jresult = result;
25522   return jresult;
25523 }
25524
25525
25526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
25527   void * jresult ;
25528   Dali::Widget *arg1 = 0 ;
25529   SwigDirector_WidgetImpl *result = 0 ;
25530
25531   arg1 = (Dali::Widget *)jarg1;
25532   if (!arg1) {
25533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
25534     return 0;
25535   }
25536   {
25537     try {
25538       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
25539     } CALL_CATCH_EXCEPTION(0);
25540   }
25541   jresult = (void*) result;
25542   return jresult;
25543 }
25544
25545
25546
25547 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
25548     return (Dali::SignalObserver *)jarg1;
25549 }
25550
25551 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
25552     return (Dali::ConnectionTrackerInterface *)jarg1;
25553 }
25554
25555 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
25556     return (Dali::BaseHandle *)jarg1;
25557 }
25558
25559 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
25560     return (Dali::BaseHandle *)jarg1;
25561 }
25562
25563 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
25564     return (Dali::BaseHandle *)jarg1;
25565 }
25566
25567 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
25568     return (Dali::BaseHandle *)jarg1;
25569 }
25570
25571 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
25572     return (Dali::BaseHandle *)jarg1;
25573 }
25574
25575 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
25576     return (Dali::BaseHandle *)jarg1;
25577 }
25578
25579 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
25580     return (Dali::BaseHandle *)jarg1;
25581 }
25582
25583 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
25584     return (Dali::BaseHandle *)jarg1;
25585 }
25586
25587 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
25588     return (Dali::BaseHandle *)jarg1;
25589 }
25590
25591 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
25592     return (Dali::BaseHandle *)jarg1;
25593 }
25594
25595 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
25596     return (Dali::BaseHandle *)jarg1;
25597 }
25598
25599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
25600     return (Dali::BaseHandle *)jarg1;
25601 }
25602
25603 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
25604     return (Dali::Handle *)jarg1;
25605 }
25606
25607 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
25608     return (Dali::Handle *)jarg1;
25609 }
25610
25611 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
25612     return (Dali::BaseHandle *)jarg1;
25613 }
25614
25615 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
25616     return (Dali::BaseHandle *)jarg1;
25617 }
25618
25619 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
25620     return (Dali::Handle *)jarg1;
25621 }
25622
25623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
25624     return (Dali::BaseHandle *)jarg1;
25625 }
25626
25627 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
25628     return (Dali::BaseHandle *)jarg1;
25629 }
25630
25631 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
25632     return (Dali::BaseHandle *)jarg1;
25633 }
25634
25635 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
25636     return (Dali::BaseHandle *)jarg1;
25637 }
25638
25639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
25640     return (Dali::BaseHandle *)jarg1;
25641 }
25642
25643 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
25644     return (Dali::Handle *)jarg1;
25645 }
25646
25647 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
25648     return (Dali::GestureDetector *)jarg1;
25649 }
25650
25651 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
25652     return (Dali::Gesture *)jarg1;
25653 }
25654
25655
25656 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
25657     return (Dali::RefObject *)jarg1;
25658 }
25659
25660 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
25661     return (Dali::Actor *)jarg1;
25662 }
25663
25664 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
25665     return (Dali::GestureDetector *)jarg1;
25666 }
25667
25668 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
25669     return (Dali::Gesture *)jarg1;
25670 }
25671
25672 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
25673     return (Dali::GestureDetector *)jarg1;
25674 }
25675
25676 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
25677     return (Dali::Gesture *)jarg1;
25678 }
25679
25680 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
25681     return (Dali::GestureDetector *)jarg1;
25682 }
25683
25684 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
25685     return (Dali::Gesture *)jarg1;
25686 }
25687
25688 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
25689     return (Dali::BaseHandle *)jarg1;
25690 }
25691
25692 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
25693     return (Dali::Handle *)jarg1;
25694 }
25695
25696 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
25697     return (Dali::Handle *)jarg1;
25698 }
25699
25700 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
25701     return (Dali::Handle *)jarg1;
25702 }
25703
25704 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
25705     return (Dali::RefObject *)jarg1;
25706 }
25707
25708 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
25709     return (Dali::Actor *)jarg1;
25710 }
25711
25712 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
25713     return (Dali::BaseHandle *)jarg1;
25714 }
25715
25716
25717 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
25718   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
25719   char * jresult = SWIG_csharp_string_callback((const char *)result);
25720   return jresult;
25721 }
25722
25723 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
25724   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
25725   return result;
25726 }
25727
25728
25729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
25730   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25731
25732   arg1 = (std::vector< unsigned int > *)jarg1;
25733   {
25734     try {
25735       (arg1)->clear();
25736     } CALL_CATCH_EXCEPTION();
25737   }
25738
25739 }
25740
25741
25742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
25743   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25744   unsigned int *arg2 = 0 ;
25745   unsigned int temp2 ;
25746
25747   arg1 = (std::vector< unsigned int > *)jarg1;
25748   temp2 = (unsigned int)jarg2;
25749   arg2 = &temp2;
25750   {
25751     try {
25752       (arg1)->push_back((unsigned int const &)*arg2);
25753     } CALL_CATCH_EXCEPTION();
25754   }
25755
25756 }
25757
25758
25759 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
25760   unsigned long jresult ;
25761   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25762   std::vector< unsigned int >::size_type result;
25763
25764   arg1 = (std::vector< unsigned int > *)jarg1;
25765   {
25766     try {
25767       result = ((std::vector< unsigned int > const *)arg1)->size();
25768     } CALL_CATCH_EXCEPTION(0);
25769   }
25770
25771   jresult = (unsigned long)result;
25772   return jresult;
25773 }
25774
25775
25776 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
25777   unsigned long jresult ;
25778   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25779   std::vector< unsigned int >::size_type result;
25780
25781   arg1 = (std::vector< unsigned int > *)jarg1;
25782   {
25783     try {
25784       result = ((std::vector< unsigned int > const *)arg1)->capacity();
25785     } CALL_CATCH_EXCEPTION(0);
25786   }
25787
25788   jresult = (unsigned long)result;
25789   return jresult;
25790 }
25791
25792
25793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
25794   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25795   std::vector< unsigned int >::size_type arg2 ;
25796
25797   arg1 = (std::vector< unsigned int > *)jarg1;
25798   arg2 = (std::vector< unsigned int >::size_type)jarg2;
25799   {
25800     try {
25801       (arg1)->reserve(arg2);
25802     } CALL_CATCH_EXCEPTION();
25803   }
25804
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
25809   void * jresult ;
25810   std::vector< unsigned int > *result = 0 ;
25811
25812   {
25813     try {
25814       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
25815     } CALL_CATCH_EXCEPTION(0);
25816   }
25817
25818   jresult = (void *)result;
25819   return jresult;
25820 }
25821
25822
25823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
25824   void * jresult ;
25825   std::vector< unsigned int > *arg1 = 0 ;
25826   std::vector< unsigned int > *result = 0 ;
25827
25828   arg1 = (std::vector< unsigned int > *)jarg1;
25829   if (!arg1) {
25830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25831     return 0;
25832   }
25833   {
25834     try {
25835       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
25836     } CALL_CATCH_EXCEPTION(0);
25837   }
25838
25839   jresult = (void *)result;
25840   return jresult;
25841 }
25842
25843
25844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
25845   void * jresult ;
25846   int arg1 ;
25847   std::vector< unsigned int > *result = 0 ;
25848
25849   arg1 = (int)jarg1;
25850   {
25851     try {
25852       try {
25853         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
25854       }
25855       catch(std::out_of_range &_e) {
25856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25857         return 0;
25858       }
25859
25860     } CALL_CATCH_EXCEPTION(0);
25861   }
25862
25863   jresult = (void *)result;
25864   return jresult;
25865 }
25866
25867
25868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
25869   unsigned int jresult ;
25870   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25871   int arg2 ;
25872   unsigned int result;
25873
25874   arg1 = (std::vector< unsigned int > *)jarg1;
25875   arg2 = (int)jarg2;
25876   {
25877     try {
25878       try {
25879         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
25880       }
25881       catch(std::out_of_range &_e) {
25882         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25883         return 0;
25884       }
25885
25886     } CALL_CATCH_EXCEPTION(0);
25887   }
25888
25889   jresult = result;
25890   return jresult;
25891 }
25892
25893
25894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
25895   unsigned int jresult ;
25896   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25897   int arg2 ;
25898   unsigned int *result = 0 ;
25899
25900   arg1 = (std::vector< unsigned int > *)jarg1;
25901   arg2 = (int)jarg2;
25902   {
25903     try {
25904       try {
25905         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
25906       }
25907       catch(std::out_of_range &_e) {
25908         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25909         return 0;
25910       }
25911
25912     } CALL_CATCH_EXCEPTION(0);
25913   }
25914
25915   jresult = *result;
25916   return jresult;
25917 }
25918
25919
25920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
25921   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25922   int arg2 ;
25923   unsigned int *arg3 = 0 ;
25924   unsigned int temp3 ;
25925
25926   arg1 = (std::vector< unsigned int > *)jarg1;
25927   arg2 = (int)jarg2;
25928   temp3 = (unsigned int)jarg3;
25929   arg3 = &temp3;
25930   {
25931     try {
25932       try {
25933         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
25934       }
25935       catch(std::out_of_range &_e) {
25936         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25937         return ;
25938       }
25939
25940     } CALL_CATCH_EXCEPTION();
25941   }
25942
25943 }
25944
25945
25946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
25947   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25948   std::vector< unsigned int > *arg2 = 0 ;
25949
25950   arg1 = (std::vector< unsigned int > *)jarg1;
25951   arg2 = (std::vector< unsigned int > *)jarg2;
25952   if (!arg2) {
25953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25954     return ;
25955   }
25956   {
25957     try {
25958       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
25959     } CALL_CATCH_EXCEPTION();
25960   }
25961
25962 }
25963
25964
25965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
25966   void * jresult ;
25967   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25968   int arg2 ;
25969   int arg3 ;
25970   std::vector< unsigned int > *result = 0 ;
25971
25972   arg1 = (std::vector< unsigned int > *)jarg1;
25973   arg2 = (int)jarg2;
25974   arg3 = (int)jarg3;
25975   {
25976     try {
25977       try {
25978         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
25979       }
25980       catch(std::out_of_range &_e) {
25981         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25982         return 0;
25983       }
25984       catch(std::invalid_argument &_e) {
25985         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
25986         return 0;
25987       }
25988
25989     } CALL_CATCH_EXCEPTION(0);
25990   }
25991
25992   jresult = (void *)result;
25993   return jresult;
25994 }
25995
25996
25997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
25998   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25999   int arg2 ;
26000   unsigned int *arg3 = 0 ;
26001   unsigned int temp3 ;
26002
26003   arg1 = (std::vector< unsigned int > *)jarg1;
26004   arg2 = (int)jarg2;
26005   temp3 = (unsigned int)jarg3;
26006   arg3 = &temp3;
26007   {
26008     try {
26009       try {
26010         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
26011       }
26012       catch(std::out_of_range &_e) {
26013         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26014         return ;
26015       }
26016
26017     } CALL_CATCH_EXCEPTION();
26018   }
26019
26020 }
26021
26022
26023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26024   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26025   int arg2 ;
26026   std::vector< unsigned int > *arg3 = 0 ;
26027
26028   arg1 = (std::vector< unsigned int > *)jarg1;
26029   arg2 = (int)jarg2;
26030   arg3 = (std::vector< unsigned int > *)jarg3;
26031   if (!arg3) {
26032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
26033     return ;
26034   }
26035   {
26036     try {
26037       try {
26038         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
26039       }
26040       catch(std::out_of_range &_e) {
26041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26042         return ;
26043       }
26044
26045     } CALL_CATCH_EXCEPTION();
26046   }
26047
26048 }
26049
26050
26051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
26052   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26053   int arg2 ;
26054
26055   arg1 = (std::vector< unsigned int > *)jarg1;
26056   arg2 = (int)jarg2;
26057   {
26058     try {
26059       try {
26060         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
26061       }
26062       catch(std::out_of_range &_e) {
26063         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26064         return ;
26065       }
26066
26067     } CALL_CATCH_EXCEPTION();
26068   }
26069
26070 }
26071
26072
26073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26074   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26075   int arg2 ;
26076   int arg3 ;
26077
26078   arg1 = (std::vector< unsigned int > *)jarg1;
26079   arg2 = (int)jarg2;
26080   arg3 = (int)jarg3;
26081   {
26082     try {
26083       try {
26084         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
26085       }
26086       catch(std::out_of_range &_e) {
26087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26088         return ;
26089       }
26090       catch(std::invalid_argument &_e) {
26091         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26092         return ;
26093       }
26094
26095     } CALL_CATCH_EXCEPTION();
26096   }
26097
26098 }
26099
26100
26101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
26102   void * jresult ;
26103   unsigned int *arg1 = 0 ;
26104   int arg2 ;
26105   unsigned int temp1 ;
26106   std::vector< unsigned int > *result = 0 ;
26107
26108   temp1 = (unsigned int)jarg1;
26109   arg1 = &temp1;
26110   arg2 = (int)jarg2;
26111   {
26112     try {
26113       try {
26114         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
26115       }
26116       catch(std::out_of_range &_e) {
26117         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26118         return 0;
26119       }
26120
26121     } CALL_CATCH_EXCEPTION(0);
26122   }
26123
26124   jresult = (void *)result;
26125   return jresult;
26126 }
26127
26128
26129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
26130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26131
26132   arg1 = (std::vector< unsigned int > *)jarg1;
26133   {
26134     try {
26135       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
26136     } CALL_CATCH_EXCEPTION();
26137   }
26138
26139 }
26140
26141
26142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26143   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26144   int arg2 ;
26145   int arg3 ;
26146
26147   arg1 = (std::vector< unsigned int > *)jarg1;
26148   arg2 = (int)jarg2;
26149   arg3 = (int)jarg3;
26150   {
26151     try {
26152       try {
26153         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26154       }
26155       catch(std::out_of_range &_e) {
26156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26157         return ;
26158       }
26159       catch(std::invalid_argument &_e) {
26160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26161         return ;
26162       }
26163
26164     } CALL_CATCH_EXCEPTION();
26165   }
26166
26167 }
26168
26169
26170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26171   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26172   int arg2 ;
26173   std::vector< unsigned int > *arg3 = 0 ;
26174
26175   arg1 = (std::vector< unsigned int > *)jarg1;
26176   arg2 = (int)jarg2;
26177   arg3 = (std::vector< unsigned int > *)jarg3;
26178   if (!arg3) {
26179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
26180     return ;
26181   }
26182   {
26183     try {
26184       try {
26185         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
26186       }
26187       catch(std::out_of_range &_e) {
26188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26189         return ;
26190       }
26191
26192     } CALL_CATCH_EXCEPTION();
26193   }
26194
26195 }
26196
26197
26198 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
26199   bool jresult ;
26200   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26201   unsigned int *arg2 = 0 ;
26202   unsigned int temp2 ;
26203   bool result;
26204
26205   arg1 = (std::vector< unsigned int > *)jarg1;
26206   temp2 = (unsigned int)jarg2;
26207   arg2 = &temp2;
26208   {
26209     try {
26210       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
26211     } CALL_CATCH_EXCEPTION(0);
26212   }
26213
26214   jresult = result;
26215   return jresult;
26216 }
26217
26218
26219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
26220   int jresult ;
26221   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26222   unsigned int *arg2 = 0 ;
26223   unsigned int temp2 ;
26224   int result;
26225
26226   arg1 = (std::vector< unsigned int > *)jarg1;
26227   temp2 = (unsigned int)jarg2;
26228   arg2 = &temp2;
26229   {
26230     try {
26231       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
26232     } CALL_CATCH_EXCEPTION(0);
26233   }
26234
26235   jresult = result;
26236   return jresult;
26237 }
26238
26239
26240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
26241   int jresult ;
26242   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26243   unsigned int *arg2 = 0 ;
26244   unsigned int temp2 ;
26245   int result;
26246
26247   arg1 = (std::vector< unsigned int > *)jarg1;
26248   temp2 = (unsigned int)jarg2;
26249   arg2 = &temp2;
26250   {
26251     try {
26252       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
26253     } CALL_CATCH_EXCEPTION(0);
26254   }
26255
26256   jresult = result;
26257   return jresult;
26258 }
26259
26260
26261 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
26262   bool jresult ;
26263   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26264   unsigned int *arg2 = 0 ;
26265   unsigned int temp2 ;
26266   bool result;
26267
26268   arg1 = (std::vector< unsigned int > *)jarg1;
26269   temp2 = (unsigned int)jarg2;
26270   arg2 = &temp2;
26271   {
26272     try {
26273       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
26274     } CALL_CATCH_EXCEPTION(0);
26275   }
26276
26277   jresult = result;
26278   return jresult;
26279 }
26280
26281
26282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
26283   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
26284
26285   arg1 = (std::vector< unsigned int > *)jarg1;
26286   {
26287     try {
26288       delete arg1;
26289     } CALL_CATCH_EXCEPTION();
26290   }
26291
26292 }
26293
26294
26295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
26296   void * jresult ;
26297   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26298
26299   {
26300     try {
26301       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
26302     } CALL_CATCH_EXCEPTION(0);
26303   }
26304
26305   jresult = (void *)result;
26306   return jresult;
26307 }
26308
26309
26310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
26311   void * jresult ;
26312   unsigned int arg1 ;
26313   Dali::Actor arg2 ;
26314   Dali::Actor *argp2 ;
26315   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26316
26317   arg1 = (unsigned int)jarg1;
26318   argp2 = (Dali::Actor *)jarg2;
26319   if (!argp2) {
26320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26321     return 0;
26322   }
26323   arg2 = *argp2;
26324   {
26325     try {
26326       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
26327     } CALL_CATCH_EXCEPTION(0);
26328   }
26329
26330   jresult = (void *)result;
26331   return jresult;
26332 }
26333
26334
26335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
26336   void * jresult ;
26337   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
26338   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26339
26340   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26341   if (!arg1) {
26342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26343     return 0;
26344   }
26345   {
26346     try {
26347       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
26348     } CALL_CATCH_EXCEPTION(0);
26349   }
26350
26351   jresult = (void *)result;
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
26357   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26358   unsigned int arg2 ;
26359
26360   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26361   arg2 = (unsigned int)jarg2;
26362   if (arg1) (arg1)->first = arg2;
26363 }
26364
26365
26366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
26367   unsigned int jresult ;
26368   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26369   unsigned int result;
26370
26371   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26372   result = (unsigned int) ((arg1)->first);
26373   jresult = result;
26374   return jresult;
26375 }
26376
26377
26378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
26379   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26380   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26381
26382   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26383   arg2 = (Dali::Actor *)jarg2;
26384   if (arg1) (arg1)->second = *arg2;
26385 }
26386
26387
26388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
26389   void * jresult ;
26390   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26391   Dali::Actor *result = 0 ;
26392
26393   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26394   result = (Dali::Actor *)& ((arg1)->second);
26395   jresult = (void *)result;
26396   return jresult;
26397 }
26398
26399
26400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
26401   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
26402
26403   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26404   {
26405     try {
26406       delete arg1;
26407     } CALL_CATCH_EXCEPTION();
26408   }
26409
26410 }
26411
26412
26413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
26414   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26415
26416   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26417   {
26418     try {
26419       (arg1)->clear();
26420     } CALL_CATCH_EXCEPTION();
26421   }
26422
26423 }
26424
26425
26426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
26427   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26428   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
26429
26430   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26431   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
26432   if (!arg2) {
26433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26434     return ;
26435   }
26436   {
26437     try {
26438       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
26439     } CALL_CATCH_EXCEPTION();
26440   }
26441
26442 }
26443
26444
26445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
26446   unsigned long jresult ;
26447   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26448   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
26449
26450   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26451   {
26452     try {
26453       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
26454     } CALL_CATCH_EXCEPTION(0);
26455   }
26456
26457   jresult = (unsigned long)result;
26458   return jresult;
26459 }
26460
26461
26462 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
26463   unsigned long jresult ;
26464   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26465   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
26466
26467   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26468   {
26469     try {
26470       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
26471     } CALL_CATCH_EXCEPTION(0);
26472   }
26473
26474   jresult = (unsigned long)result;
26475   return jresult;
26476 }
26477
26478
26479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
26480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26481   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
26482
26483   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26484   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
26485   {
26486     try {
26487       (arg1)->reserve(arg2);
26488     } CALL_CATCH_EXCEPTION();
26489   }
26490
26491 }
26492
26493
26494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
26495   void * jresult ;
26496   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26497
26498   {
26499     try {
26500       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
26501     } CALL_CATCH_EXCEPTION(0);
26502   }
26503
26504   jresult = (void *)result;
26505   return jresult;
26506 }
26507
26508
26509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
26510   void * jresult ;
26511   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
26512   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26513
26514   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26515   if (!arg1) {
26516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26517     return 0;
26518   }
26519   {
26520     try {
26521       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);
26522     } CALL_CATCH_EXCEPTION(0);
26523   }
26524
26525   jresult = (void *)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
26531   void * jresult ;
26532   int arg1 ;
26533   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26534
26535   arg1 = (int)jarg1;
26536   {
26537     try {
26538       try {
26539         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);
26540       }
26541       catch(std::out_of_range &_e) {
26542         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26543         return 0;
26544       }
26545
26546     } CALL_CATCH_EXCEPTION(0);
26547   }
26548
26549   jresult = (void *)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
26555   void * jresult ;
26556   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26557   int arg2 ;
26558   std::pair< unsigned int,Dali::Actor > result;
26559
26560   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26561   arg2 = (int)jarg2;
26562   {
26563     try {
26564       try {
26565         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
26566       }
26567       catch(std::out_of_range &_e) {
26568         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26569         return 0;
26570       }
26571
26572     } CALL_CATCH_EXCEPTION(0);
26573   }
26574
26575   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
26581   void * jresult ;
26582   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26583   int arg2 ;
26584   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26585
26586   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26587   arg2 = (int)jarg2;
26588   {
26589     try {
26590       try {
26591         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
26592       }
26593       catch(std::out_of_range &_e) {
26594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26595         return 0;
26596       }
26597
26598     } CALL_CATCH_EXCEPTION(0);
26599   }
26600
26601   jresult = (void *)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
26607   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26608   int arg2 ;
26609   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
26610
26611   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26612   arg2 = (int)jarg2;
26613   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
26614   if (!arg3) {
26615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26616     return ;
26617   }
26618   {
26619     try {
26620       try {
26621         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);
26622       }
26623       catch(std::out_of_range &_e) {
26624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26625         return ;
26626       }
26627
26628     } CALL_CATCH_EXCEPTION();
26629   }
26630
26631 }
26632
26633
26634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
26635   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26636   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
26637
26638   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26639   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
26640   if (!arg2) {
26641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26642     return ;
26643   }
26644   {
26645     try {
26646       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);
26647     } CALL_CATCH_EXCEPTION();
26648   }
26649
26650 }
26651
26652
26653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
26654   void * jresult ;
26655   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26656   int arg2 ;
26657   int arg3 ;
26658   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26659
26660   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26661   arg2 = (int)jarg2;
26662   arg3 = (int)jarg3;
26663   {
26664     try {
26665       try {
26666         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);
26667       }
26668       catch(std::out_of_range &_e) {
26669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26670         return 0;
26671       }
26672       catch(std::invalid_argument &_e) {
26673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26674         return 0;
26675       }
26676
26677     } CALL_CATCH_EXCEPTION(0);
26678   }
26679
26680   jresult = (void *)result;
26681   return jresult;
26682 }
26683
26684
26685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
26686   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26687   int arg2 ;
26688   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
26689
26690   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26691   arg2 = (int)jarg2;
26692   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
26693   if (!arg3) {
26694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26695     return ;
26696   }
26697   {
26698     try {
26699       try {
26700         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);
26701       }
26702       catch(std::out_of_range &_e) {
26703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26704         return ;
26705       }
26706
26707     } CALL_CATCH_EXCEPTION();
26708   }
26709
26710 }
26711
26712
26713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26714   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26715   int arg2 ;
26716   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
26717
26718   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26719   arg2 = (int)jarg2;
26720   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
26721   if (!arg3) {
26722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26723     return ;
26724   }
26725   {
26726     try {
26727       try {
26728         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);
26729       }
26730       catch(std::out_of_range &_e) {
26731         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26732         return ;
26733       }
26734
26735     } CALL_CATCH_EXCEPTION();
26736   }
26737
26738 }
26739
26740
26741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
26742   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26743   int arg2 ;
26744
26745   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26746   arg2 = (int)jarg2;
26747   {
26748     try {
26749       try {
26750         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
26751       }
26752       catch(std::out_of_range &_e) {
26753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26754         return ;
26755       }
26756
26757     } CALL_CATCH_EXCEPTION();
26758   }
26759
26760 }
26761
26762
26763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26764   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26765   int arg2 ;
26766   int arg3 ;
26767
26768   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26769   arg2 = (int)jarg2;
26770   arg3 = (int)jarg3;
26771   {
26772     try {
26773       try {
26774         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
26775       }
26776       catch(std::out_of_range &_e) {
26777         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26778         return ;
26779       }
26780       catch(std::invalid_argument &_e) {
26781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26782         return ;
26783       }
26784
26785     } CALL_CATCH_EXCEPTION();
26786   }
26787
26788 }
26789
26790
26791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
26792   void * jresult ;
26793   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
26794   int arg2 ;
26795   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26796
26797   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26798   if (!arg1) {
26799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26800     return 0;
26801   }
26802   arg2 = (int)jarg2;
26803   {
26804     try {
26805       try {
26806         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);
26807       }
26808       catch(std::out_of_range &_e) {
26809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26810         return 0;
26811       }
26812
26813     } CALL_CATCH_EXCEPTION(0);
26814   }
26815
26816   jresult = (void *)result;
26817   return jresult;
26818 }
26819
26820
26821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
26822   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26823
26824   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26825   {
26826     try {
26827       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
26828     } CALL_CATCH_EXCEPTION();
26829   }
26830
26831 }
26832
26833
26834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26835   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26836   int arg2 ;
26837   int arg3 ;
26838
26839   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26840   arg2 = (int)jarg2;
26841   arg3 = (int)jarg3;
26842   {
26843     try {
26844       try {
26845         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26846       }
26847       catch(std::out_of_range &_e) {
26848         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26849         return ;
26850       }
26851       catch(std::invalid_argument &_e) {
26852         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26853         return ;
26854       }
26855
26856     } CALL_CATCH_EXCEPTION();
26857   }
26858
26859 }
26860
26861
26862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26863   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26864   int arg2 ;
26865   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
26866
26867   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26868   arg2 = (int)jarg2;
26869   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
26870   if (!arg3) {
26871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26872     return ;
26873   }
26874   {
26875     try {
26876       try {
26877         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);
26878       }
26879       catch(std::out_of_range &_e) {
26880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26881         return ;
26882       }
26883
26884     } CALL_CATCH_EXCEPTION();
26885   }
26886
26887 }
26888
26889
26890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
26891   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26892
26893   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26894   {
26895     try {
26896       delete arg1;
26897     } CALL_CATCH_EXCEPTION();
26898   }
26899
26900 }
26901
26902
26903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
26904   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26905
26906   arg1 = (std::vector< Dali::Actor > *)jarg1;
26907   {
26908     try {
26909       (arg1)->clear();
26910     } CALL_CATCH_EXCEPTION();
26911   }
26912
26913 }
26914
26915
26916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
26917   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26918   Dali::Actor *arg2 = 0 ;
26919
26920   arg1 = (std::vector< Dali::Actor > *)jarg1;
26921   arg2 = (Dali::Actor *)jarg2;
26922   if (!arg2) {
26923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26924     return ;
26925   }
26926   {
26927     try {
26928       (arg1)->push_back((Dali::Actor const &)*arg2);
26929     } CALL_CATCH_EXCEPTION();
26930   }
26931
26932 }
26933
26934
26935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
26936   unsigned long jresult ;
26937   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26938   std::vector< Dali::Actor >::size_type result;
26939
26940   arg1 = (std::vector< Dali::Actor > *)jarg1;
26941   {
26942     try {
26943       result = ((std::vector< Dali::Actor > const *)arg1)->size();
26944     } CALL_CATCH_EXCEPTION(0);
26945   }
26946
26947   jresult = (unsigned long)result;
26948   return jresult;
26949 }
26950
26951
26952 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
26953   unsigned long jresult ;
26954   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26955   std::vector< Dali::Actor >::size_type result;
26956
26957   arg1 = (std::vector< Dali::Actor > *)jarg1;
26958   {
26959     try {
26960       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
26961     } CALL_CATCH_EXCEPTION(0);
26962   }
26963
26964   jresult = (unsigned long)result;
26965   return jresult;
26966 }
26967
26968
26969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
26970   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26971   std::vector< Dali::Actor >::size_type arg2 ;
26972
26973   arg1 = (std::vector< Dali::Actor > *)jarg1;
26974   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
26975   {
26976     try {
26977       (arg1)->reserve(arg2);
26978     } CALL_CATCH_EXCEPTION();
26979   }
26980
26981 }
26982
26983
26984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
26985   void * jresult ;
26986   std::vector< Dali::Actor > *result = 0 ;
26987
26988   {
26989     try {
26990       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
26991     } CALL_CATCH_EXCEPTION(0);
26992   }
26993
26994   jresult = (void *)result;
26995   return jresult;
26996 }
26997
26998
26999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
27000   void * jresult ;
27001   std::vector< Dali::Actor > *arg1 = 0 ;
27002   std::vector< Dali::Actor > *result = 0 ;
27003
27004   arg1 = (std::vector< Dali::Actor > *)jarg1;
27005   if (!arg1) {
27006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27007     return 0;
27008   }
27009   {
27010     try {
27011       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
27012     } CALL_CATCH_EXCEPTION(0);
27013   }
27014
27015   jresult = (void *)result;
27016   return jresult;
27017 }
27018
27019
27020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
27021   void * jresult ;
27022   int arg1 ;
27023   std::vector< Dali::Actor > *result = 0 ;
27024
27025   arg1 = (int)jarg1;
27026   {
27027     try {
27028       try {
27029         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
27030       }
27031       catch(std::out_of_range &_e) {
27032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27033         return 0;
27034       }
27035
27036     } CALL_CATCH_EXCEPTION(0);
27037   }
27038
27039   jresult = (void *)result;
27040   return jresult;
27041 }
27042
27043
27044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
27045   void * jresult ;
27046   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27047   int arg2 ;
27048   Dali::Actor result;
27049
27050   arg1 = (std::vector< Dali::Actor > *)jarg1;
27051   arg2 = (int)jarg2;
27052   {
27053     try {
27054       try {
27055         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
27056       }
27057       catch(std::out_of_range &_e) {
27058         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27059         return 0;
27060       }
27061
27062     } CALL_CATCH_EXCEPTION(0);
27063   }
27064
27065   jresult = new Dali::Actor((const Dali::Actor &)result);
27066   return jresult;
27067 }
27068
27069
27070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
27071   void * jresult ;
27072   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27073   int arg2 ;
27074   Dali::Actor *result = 0 ;
27075
27076   arg1 = (std::vector< Dali::Actor > *)jarg1;
27077   arg2 = (int)jarg2;
27078   {
27079     try {
27080       try {
27081         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
27082       }
27083       catch(std::out_of_range &_e) {
27084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27085         return 0;
27086       }
27087
27088     } CALL_CATCH_EXCEPTION(0);
27089   }
27090
27091   jresult = (void *)result;
27092   return jresult;
27093 }
27094
27095
27096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
27097   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27098   int arg2 ;
27099   Dali::Actor *arg3 = 0 ;
27100
27101   arg1 = (std::vector< Dali::Actor > *)jarg1;
27102   arg2 = (int)jarg2;
27103   arg3 = (Dali::Actor *)jarg3;
27104   if (!arg3) {
27105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27106     return ;
27107   }
27108   {
27109     try {
27110       try {
27111         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
27112       }
27113       catch(std::out_of_range &_e) {
27114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27115         return ;
27116       }
27117
27118     } CALL_CATCH_EXCEPTION();
27119   }
27120
27121 }
27122
27123
27124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
27125   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27126   std::vector< Dali::Actor > *arg2 = 0 ;
27127
27128   arg1 = (std::vector< Dali::Actor > *)jarg1;
27129   arg2 = (std::vector< Dali::Actor > *)jarg2;
27130   if (!arg2) {
27131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27132     return ;
27133   }
27134   {
27135     try {
27136       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
27137     } CALL_CATCH_EXCEPTION();
27138   }
27139
27140 }
27141
27142
27143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
27144   void * jresult ;
27145   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27146   int arg2 ;
27147   int arg3 ;
27148   std::vector< Dali::Actor > *result = 0 ;
27149
27150   arg1 = (std::vector< Dali::Actor > *)jarg1;
27151   arg2 = (int)jarg2;
27152   arg3 = (int)jarg3;
27153   {
27154     try {
27155       try {
27156         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
27157       }
27158       catch(std::out_of_range &_e) {
27159         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27160         return 0;
27161       }
27162       catch(std::invalid_argument &_e) {
27163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
27164         return 0;
27165       }
27166
27167     } CALL_CATCH_EXCEPTION(0);
27168   }
27169
27170   jresult = (void *)result;
27171   return jresult;
27172 }
27173
27174
27175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
27176   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27177   int arg2 ;
27178   Dali::Actor *arg3 = 0 ;
27179
27180   arg1 = (std::vector< Dali::Actor > *)jarg1;
27181   arg2 = (int)jarg2;
27182   arg3 = (Dali::Actor *)jarg3;
27183   if (!arg3) {
27184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27185     return ;
27186   }
27187   {
27188     try {
27189       try {
27190         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
27191       }
27192       catch(std::out_of_range &_e) {
27193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27194         return ;
27195       }
27196
27197     } CALL_CATCH_EXCEPTION();
27198   }
27199
27200 }
27201
27202
27203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
27204   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27205   int arg2 ;
27206   std::vector< Dali::Actor > *arg3 = 0 ;
27207
27208   arg1 = (std::vector< Dali::Actor > *)jarg1;
27209   arg2 = (int)jarg2;
27210   arg3 = (std::vector< Dali::Actor > *)jarg3;
27211   if (!arg3) {
27212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27213     return ;
27214   }
27215   {
27216     try {
27217       try {
27218         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
27219       }
27220       catch(std::out_of_range &_e) {
27221         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27222         return ;
27223       }
27224
27225     } CALL_CATCH_EXCEPTION();
27226   }
27227
27228 }
27229
27230
27231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
27232   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27233   int arg2 ;
27234
27235   arg1 = (std::vector< Dali::Actor > *)jarg1;
27236   arg2 = (int)jarg2;
27237   {
27238     try {
27239       try {
27240         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
27241       }
27242       catch(std::out_of_range &_e) {
27243         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27244         return ;
27245       }
27246
27247     } CALL_CATCH_EXCEPTION();
27248   }
27249
27250 }
27251
27252
27253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
27254   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27255   int arg2 ;
27256   int arg3 ;
27257
27258   arg1 = (std::vector< Dali::Actor > *)jarg1;
27259   arg2 = (int)jarg2;
27260   arg3 = (int)jarg3;
27261   {
27262     try {
27263       try {
27264         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
27265       }
27266       catch(std::out_of_range &_e) {
27267         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27268         return ;
27269       }
27270       catch(std::invalid_argument &_e) {
27271         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
27272         return ;
27273       }
27274
27275     } CALL_CATCH_EXCEPTION();
27276   }
27277
27278 }
27279
27280
27281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
27282   void * jresult ;
27283   Dali::Actor *arg1 = 0 ;
27284   int arg2 ;
27285   std::vector< Dali::Actor > *result = 0 ;
27286
27287   arg1 = (Dali::Actor *)jarg1;
27288   if (!arg1) {
27289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27290     return 0;
27291   }
27292   arg2 = (int)jarg2;
27293   {
27294     try {
27295       try {
27296         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
27297       }
27298       catch(std::out_of_range &_e) {
27299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27300         return 0;
27301       }
27302
27303     } CALL_CATCH_EXCEPTION(0);
27304   }
27305
27306   jresult = (void *)result;
27307   return jresult;
27308 }
27309
27310
27311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
27312   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27313
27314   arg1 = (std::vector< Dali::Actor > *)jarg1;
27315   {
27316     try {
27317       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
27318     } CALL_CATCH_EXCEPTION();
27319   }
27320
27321 }
27322
27323
27324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
27325   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27326   int arg2 ;
27327   int arg3 ;
27328
27329   arg1 = (std::vector< Dali::Actor > *)jarg1;
27330   arg2 = (int)jarg2;
27331   arg3 = (int)jarg3;
27332   {
27333     try {
27334       try {
27335         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
27336       }
27337       catch(std::out_of_range &_e) {
27338         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27339         return ;
27340       }
27341       catch(std::invalid_argument &_e) {
27342         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
27343         return ;
27344       }
27345
27346     } CALL_CATCH_EXCEPTION();
27347   }
27348
27349 }
27350
27351
27352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
27353   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27354   int arg2 ;
27355   std::vector< Dali::Actor > *arg3 = 0 ;
27356
27357   arg1 = (std::vector< Dali::Actor > *)jarg1;
27358   arg2 = (int)jarg2;
27359   arg3 = (std::vector< Dali::Actor > *)jarg3;
27360   if (!arg3) {
27361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
27362     return ;
27363   }
27364   {
27365     try {
27366       try {
27367         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
27368       }
27369       catch(std::out_of_range &_e) {
27370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
27371         return ;
27372       }
27373
27374     } CALL_CATCH_EXCEPTION();
27375   }
27376
27377 }
27378
27379
27380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
27381   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
27382
27383   arg1 = (std::vector< Dali::Actor > *)jarg1;
27384   {
27385     try {
27386       delete arg1;
27387     } CALL_CATCH_EXCEPTION();
27388   }
27389
27390 }
27391
27392
27393 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
27394   bool jresult ;
27395   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27396   bool result;
27397
27398   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27399   {
27400     try {
27401       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
27402     } CALL_CATCH_EXCEPTION(0);
27403   }
27404
27405   jresult = result;
27406   return jresult;
27407 }
27408
27409
27410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
27411   unsigned long jresult ;
27412   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27413   std::size_t result;
27414
27415   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27416   {
27417     try {
27418       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
27419     } CALL_CATCH_EXCEPTION(0);
27420   }
27421
27422   jresult = (unsigned long)result;
27423   return jresult;
27424 }
27425
27426
27427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
27428   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27429   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
27430
27431   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27432   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
27433   {
27434     try {
27435       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
27436     } CALL_CATCH_EXCEPTION();
27437   }
27438
27439 }
27440
27441
27442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
27443   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27444   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
27445
27446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27447   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
27448   {
27449     try {
27450       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
27451     } CALL_CATCH_EXCEPTION();
27452   }
27453
27454 }
27455
27456
27457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
27458   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27459   Dali::Actor arg2 ;
27460   Dali::Actor arg3 ;
27461   Dali::Actor *argp2 ;
27462   Dali::Actor *argp3 ;
27463
27464   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27465   argp2 = (Dali::Actor *)jarg2;
27466   if (!argp2) {
27467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27468     return ;
27469   }
27470   arg2 = *argp2;
27471   argp3 = (Dali::Actor *)jarg3;
27472   if (!argp3) {
27473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27474     return ;
27475   }
27476   arg3 = *argp3;
27477   {
27478     try {
27479       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
27480     } CALL_CATCH_EXCEPTION();
27481   }
27482
27483 }
27484
27485
27486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
27487   void * jresult ;
27488   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
27489
27490   {
27491     try {
27492       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
27493     } CALL_CATCH_EXCEPTION(0);
27494   }
27495
27496   jresult = (void *)result;
27497   return jresult;
27498 }
27499
27500
27501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
27502   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27503
27504   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27505   {
27506     try {
27507       delete arg1;
27508     } CALL_CATCH_EXCEPTION();
27509   }
27510
27511 }
27512
27513
27514 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
27515   bool jresult ;
27516   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27517   bool result;
27518
27519   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27520   {
27521     try {
27522       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
27523     } CALL_CATCH_EXCEPTION(0);
27524   }
27525
27526   jresult = result;
27527   return jresult;
27528 }
27529
27530
27531 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
27532   unsigned long jresult ;
27533   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27534   std::size_t result;
27535
27536   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27537   {
27538     try {
27539       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
27540     } CALL_CATCH_EXCEPTION(0);
27541   }
27542
27543   jresult = (unsigned long)result;
27544   return jresult;
27545 }
27546
27547
27548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
27549   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27550   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
27551
27552   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27553   arg2 = (void (*)(Dali::Actor,bool))jarg2;
27554   {
27555     try {
27556       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
27557     } CALL_CATCH_EXCEPTION();
27558   }
27559
27560 }
27561
27562
27563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
27564   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27565   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
27566
27567   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27568   arg2 = (void (*)(Dali::Actor,bool))jarg2;
27569   {
27570     try {
27571       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
27572     } CALL_CATCH_EXCEPTION();
27573   }
27574
27575 }
27576
27577
27578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
27579   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27580   Dali::Actor arg2 ;
27581   bool arg3 ;
27582   Dali::Actor *argp2 ;
27583
27584   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27585   argp2 = (Dali::Actor *)jarg2;
27586   if (!argp2) {
27587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27588     return ;
27589   }
27590   arg2 = *argp2;
27591   arg3 = jarg3 ? true : false;
27592   {
27593     try {
27594       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
27595     } CALL_CATCH_EXCEPTION();
27596   }
27597
27598 }
27599
27600
27601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
27602   void * jresult ;
27603   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
27604
27605   {
27606     try {
27607       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
27608     } CALL_CATCH_EXCEPTION(0);
27609   }
27610
27611   jresult = (void *)result;
27612   return jresult;
27613 }
27614
27615
27616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
27617   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27618
27619   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27620   {
27621     try {
27622       delete arg1;
27623     } CALL_CATCH_EXCEPTION();
27624   }
27625
27626 }
27627
27628
27629 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
27630 {
27631   Dali::Toolkit::ImageUrl result;
27632   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
27633   void *jresult;
27634
27635   if (!nativeImageSource)
27636   {
27637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
27638     return 0;
27639   }
27640   {
27641     try
27642     {
27643       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
27644     }
27645     catch (std::out_of_range& e)
27646     {
27647       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27648       return 0;
27649     }
27650     catch (std::exception& e)
27651     {
27652       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27653       return 0;
27654     }
27655     catch (Dali::DaliException e)
27656     {
27657       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27658       return 0;
27659     }
27660     catch (...)
27661     {
27662       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27663       return 0;
27664     }
27665   }
27666
27667   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
27668   return jresult;
27669 }
27670
27671
27672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
27673 {
27674   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
27675
27676   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
27677   {
27678     try
27679     {
27680       delete imageUrl;
27681     }
27682     catch (std::out_of_range& e)
27683     {
27684       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27685       return;
27686     }
27687     catch (std::exception& e)
27688     {
27689       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27690       return;
27691     }
27692     catch (Dali::DaliException e)
27693     {
27694       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27695       return;
27696     }
27697     catch (...)
27698     {
27699       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27700       return;
27701     }
27702   }
27703 }
27704
27705 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
27706 {
27707   char *jresult;
27708   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
27709   std::string result;
27710
27711   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
27712   {
27713     try
27714     {
27715       result = imageUrl->GetUrl();
27716     }
27717     catch (std::out_of_range& e)
27718     {
27719       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27720       return 0;
27721     }
27722     catch (std::exception& e)
27723     {
27724       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27725       return 0;
27726     }
27727     catch (Dali::DaliException e)
27728     {
27729       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27730       return 0;
27731     }
27732     catch (...)
27733     {
27734       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27735       return 0;
27736     }
27737   }
27738
27739   jresult = SWIG_csharp_string_callback((&result)->c_str());
27740   return jresult;
27741 }
27742
27743
27744 // TODO : SwigDirector_ViewImpl
27745
27746
27747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
27748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27749   int arg2 ;
27750   SwigDirector_ViewImpl *darg = 0;
27751
27752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27753   arg2 = (int)jarg2;
27754   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27755   if(!darg) {
27756     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27757     return;
27758   }
27759   {
27760     try {
27761       if(darg) {
27762         (darg)->OnSceneConnection(arg2);
27763       }
27764     } CALL_CATCH_EXCEPTION();
27765   }
27766
27767 }
27768
27769
27770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
27771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27772   int arg2 ;
27773   SwigDirector_ViewImpl *darg = 0;
27774
27775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27776   arg2 = (int)jarg2;
27777   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27778   if(!darg) {
27779     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27780     return;
27781   }
27782   {
27783     try {
27784       if(darg) {
27785         (darg)->OnSceneConnectionSwigPublic(arg2);
27786       }
27787     } CALL_CATCH_EXCEPTION();
27788   }
27789
27790 }
27791
27792
27793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
27794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27795   SwigDirector_ViewImpl *darg = 0;
27796
27797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27798   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27799   if(!darg) {
27800     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27801     return;
27802   }
27803   {
27804     try {
27805       if(darg) {
27806         (darg)->OnSceneDisconnection();
27807       }
27808     } CALL_CATCH_EXCEPTION();
27809   }
27810
27811 }
27812
27813
27814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
27815   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27816   SwigDirector_ViewImpl *darg = 0;
27817
27818   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27819   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27820   if(!darg) {
27821     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27822     return;
27823   }
27824   {
27825     try {
27826       if(darg) {
27827         (darg)->OnSceneDisconnectionSwigPublic();
27828       }
27829     } CALL_CATCH_EXCEPTION();
27830   }
27831
27832 }
27833
27834
27835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
27836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27837   Dali::Actor *arg2 = 0 ;
27838   SwigDirector_ViewImpl *darg = 0;
27839
27840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27841   arg2 = (Dali::Actor *)jarg2;
27842   if (!arg2) {
27843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27844     return ;
27845   }
27846   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27847   if(!darg) {
27848     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27849     return;
27850   }
27851   {
27852     try {
27853       if(darg) {
27854         (darg)->OnChildAdd(*arg2);
27855       }
27856     } CALL_CATCH_EXCEPTION();
27857   }
27858
27859 }
27860
27861
27862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27864   Dali::Actor *arg2 = 0 ;
27865   SwigDirector_ViewImpl *darg = 0;
27866
27867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27868   arg2 = (Dali::Actor *)jarg2;
27869   if (!arg2) {
27870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27871     return ;
27872   }
27873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27874   if(!darg) {
27875     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27876     return;
27877   }
27878   {
27879     try {
27880       if(darg) {
27881           (darg)->OnChildAddSwigPublic(*arg2);
27882       }
27883     } CALL_CATCH_EXCEPTION();
27884   }
27885
27886 }
27887
27888
27889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
27890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27891   Dali::Actor *arg2 = 0 ;
27892   SwigDirector_ViewImpl *darg = 0;
27893
27894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27895   arg2 = (Dali::Actor *)jarg2;
27896   if (!arg2) {
27897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27898     return ;
27899   }
27900   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27901   if(!darg) {
27902     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27903     return;
27904   }
27905   {
27906     try {
27907       if(darg) {
27908         (darg)->OnChildRemove(*arg2);
27909       }
27910     } CALL_CATCH_EXCEPTION();
27911   }
27912
27913 }
27914
27915
27916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27918   Dali::Actor *arg2 = 0 ;
27919   SwigDirector_ViewImpl *darg = 0;
27920
27921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27922   arg2 = (Dali::Actor *)jarg2;
27923   if (!arg2) {
27924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27925     return ;
27926   }
27927   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27928   if(!darg) {
27929     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27930     return;
27931   }
27932   {
27933     try {
27934       if(darg) {
27935         (darg)->OnChildRemoveSwigPublic(*arg2);
27936       }
27937     } CALL_CATCH_EXCEPTION();
27938   }
27939
27940 }
27941
27942
27943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
27944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27945   Dali::Property::Index arg2 ;
27946   Dali::Property::Value arg3 ;
27947   Dali::Property::Value *argp3 ;
27948   SwigDirector_ViewImpl *darg = 0;
27949
27950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27951   arg2 = (Dali::Property::Index)jarg2;
27952   argp3 = (Dali::Property::Value *)jarg3;
27953   if (!argp3) {
27954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27955     return ;
27956   }
27957   arg3 = *argp3;
27958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27959   if (!darg) {
27960     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27961     return;
27962   }
27963   {
27964     try {
27965       (darg)->OnPropertySet(arg2,arg3);
27966     } CALL_CATCH_EXCEPTION();
27967   }
27968
27969 }
27970
27971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
27972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27973   Dali::Property::Index arg2 ;
27974   Dali::Property::Value arg3 ;
27975   Dali::Property::Value *argp3 ;
27976   SwigDirector_ViewImpl *darg = 0;
27977
27978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27979   arg2 = (Dali::Property::Index)jarg2;
27980   argp3 = (Dali::Property::Value *)jarg3;
27981   if (!argp3) {
27982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27983     return ;
27984   }
27985   arg3 = *argp3;
27986   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27987   if (!darg) {
27988     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27989     return;
27990   }
27991   {
27992     try {
27993       (darg)->OnPropertySetSwigPublic(arg2,arg3);
27994     } CALL_CATCH_EXCEPTION();
27995   }
27996
27997 }
27998
27999
28000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
28001   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28002   Dali::Vector3 *arg2 = 0 ;
28003   SwigDirector_ViewImpl *darg = 0;
28004
28005   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28006   arg2 = (Dali::Vector3 *)jarg2;
28007   if (!arg2) {
28008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28009     return ;
28010   }
28011   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28012   if (!darg) {
28013     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28014     return;
28015   }
28016   {
28017     try {
28018       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
28019     } CALL_CATCH_EXCEPTION();
28020   }
28021
28022 }
28023
28024
28025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
28026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28027   Dali::Vector3 *arg2 = 0 ;
28028   SwigDirector_ViewImpl *darg = 0;
28029
28030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28031   arg2 = (Dali::Vector3 *)jarg2;
28032   if (!arg2) {
28033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28034     return ;
28035   }
28036   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28037   if (!darg) {
28038     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28039     return;
28040   }
28041   {
28042     try {
28043       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
28044     } CALL_CATCH_EXCEPTION();
28045   }
28046
28047 }
28048
28049
28050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
28051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28052   Dali::Animation *arg2 = 0 ;
28053   Dali::Vector3 *arg3 = 0 ;
28054   SwigDirector_ViewImpl *darg = 0;
28055
28056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28057   arg2 = (Dali::Animation *)jarg2;
28058   if (!arg2) {
28059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
28060     return ;
28061   }
28062   arg3 = (Dali::Vector3 *)jarg3;
28063   if (!arg3) {
28064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28065     return ;
28066   }
28067   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28068   if (!darg) {
28069     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28070     return;
28071   }
28072   {
28073     try {
28074       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
28075     } CALL_CATCH_EXCEPTION();
28076   }
28077
28078 }
28079
28080
28081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
28082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28083   Dali::Animation *arg2 = 0 ;
28084   Dali::Vector3 *arg3 = 0 ;
28085   SwigDirector_ViewImpl *darg = 0;
28086
28087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28088   arg2 = (Dali::Animation *)jarg2;
28089   if (!arg2) {
28090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
28091     return ;
28092   }
28093   arg3 = (Dali::Vector3 *)jarg3;
28094   if (!arg3) {
28095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
28096     return ;
28097   }
28098   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28099   if (!darg) {
28100     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28101     return;
28102   }
28103   {
28104     try {
28105       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
28106     } CALL_CATCH_EXCEPTION();
28107   }
28108 }
28109
28110 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
28111   bool jresult ;
28112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28113   Dali::KeyEvent *arg2 = 0 ;
28114   SwigDirector_ViewImpl *darg = 0;
28115   bool result;
28116
28117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28118   arg2 = (Dali::KeyEvent *)jarg2;
28119   if (!arg2) {
28120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28121     return 0;
28122   }
28123   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28124   if (!darg) {
28125     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28126     return 0;
28127   }
28128   {
28129     try {
28130       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
28131     } CALL_CATCH_EXCEPTION(0);
28132   }
28133
28134   jresult = result;
28135   return jresult;
28136 }
28137
28138
28139 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
28140   bool jresult ;
28141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28142   Dali::KeyEvent *arg2 = 0 ;
28143   SwigDirector_ViewImpl *darg = 0;
28144   bool result;
28145
28146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28147   arg2 = (Dali::KeyEvent *)jarg2;
28148   if (!arg2) {
28149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28150     return 0;
28151   }
28152   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28153   if (!darg) {
28154     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28155     return 0;
28156   }
28157   {
28158     try {
28159       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
28160     } CALL_CATCH_EXCEPTION(0);
28161   }
28162
28163   jresult = result;
28164   return jresult;
28165 }
28166
28167
28168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
28169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28170   Dali::Vector2 *arg2 = 0 ;
28171   Dali::RelayoutContainer *arg3 = 0 ;
28172   SwigDirector_ViewImpl *darg = 0;
28173
28174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28175   arg2 = (Dali::Vector2 *)jarg2;
28176   if (!arg2) {
28177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28178     return ;
28179   }
28180   arg3 = (Dali::RelayoutContainer *)jarg3;
28181   if (!arg3) {
28182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
28183     return ;
28184   }
28185   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28186   if (!darg) {
28187     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28188     return;
28189   }
28190   {
28191     try {
28192       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
28193     } CALL_CATCH_EXCEPTION();
28194   }
28195
28196 }
28197
28198
28199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
28200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28201   Dali::Vector2 *arg2 = 0 ;
28202   Dali::RelayoutContainer *arg3 = 0 ;
28203   SwigDirector_ViewImpl *darg = 0;
28204
28205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28206   arg2 = (Dali::Vector2 *)jarg2;
28207   if (!arg2) {
28208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
28209     return ;
28210   }
28211   arg3 = (Dali::RelayoutContainer *)jarg3;
28212   if (!arg3) {
28213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
28214     return ;
28215   }
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)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
28224     } CALL_CATCH_EXCEPTION();
28225   }
28226
28227 }
28228
28229
28230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(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)->OnSetResizePolicy(arg2,arg3);
28247     } CALL_CATCH_EXCEPTION();
28248   }
28249
28250 }
28251
28252
28253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
28254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28255   Dali::ResizePolicy::Type arg2 ;
28256   Dali::Dimension::Type arg3 ;
28257   SwigDirector_ViewImpl *darg = 0;
28258
28259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28260   arg2 = (Dali::ResizePolicy::Type)jarg2;
28261   arg3 = (Dali::Dimension::Type)jarg3;
28262   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28263   if (!darg) {
28264     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28265     return;
28266   }
28267   {
28268     try {
28269       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
28270     } CALL_CATCH_EXCEPTION();
28271   }
28272
28273 }
28274
28275
28276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(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)->GetNaturalSize();
28291     } CALL_CATCH_EXCEPTION(0);
28292   }
28293
28294   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28295   return jresult;
28296 }
28297
28298
28299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
28300   void * jresult ;
28301   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28302   SwigDirector_ViewImpl *darg = 0;
28303   Dali::Vector3 result;
28304
28305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28306   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28307   if (!darg) {
28308     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28309     return 0;
28310   }
28311   {
28312     try {
28313       result = (darg)->GetNaturalSizeSwigPublic();
28314     } CALL_CATCH_EXCEPTION(0);
28315   }
28316
28317   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
28318   return jresult;
28319 }
28320
28321
28322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
28323   float jresult ;
28324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28325   Dali::Actor *arg2 = 0 ;
28326   Dali::Dimension::Type arg3 ;
28327   SwigDirector_ViewImpl *darg = 0;
28328   float result;
28329
28330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28331   arg2 = (Dali::Actor *)jarg2;
28332   if (!arg2) {
28333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28334     return 0;
28335   }
28336   arg3 = (Dali::Dimension::Type)jarg3;
28337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28338   if (!darg) {
28339     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28340     return 0;
28341   }
28342   {
28343     try {
28344       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
28345     } CALL_CATCH_EXCEPTION(0);
28346   }
28347
28348   jresult = result;
28349   return jresult;
28350 }
28351
28352
28353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
28354   float jresult ;
28355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28356   Dali::Actor *arg2 = 0 ;
28357   Dali::Dimension::Type arg3 ;
28358   SwigDirector_ViewImpl *darg = 0;
28359   float result;
28360
28361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28362   arg2 = (Dali::Actor *)jarg2;
28363   if (!arg2) {
28364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
28365     return 0;
28366   }
28367   arg3 = (Dali::Dimension::Type)jarg3;
28368   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28369   if (!darg) {
28370     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28371     return 0;
28372   }
28373   {
28374     try {
28375       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
28376     } CALL_CATCH_EXCEPTION(0);
28377   }
28378
28379   jresult = result;
28380   return jresult;
28381 }
28382
28383
28384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
28385   float jresult ;
28386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28387   float arg2 ;
28388   SwigDirector_ViewImpl *darg = 0;
28389   float result;
28390
28391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28392   arg2 = (float)jarg2;
28393   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28394   if (!darg) {
28395     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28396     return 0;
28397   }
28398   {
28399     try {
28400       result = (float)(darg)->GetHeightForWidth(arg2);
28401     } CALL_CATCH_EXCEPTION(0);
28402   }
28403
28404   jresult = result;
28405   return jresult;
28406 }
28407
28408
28409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
28410   float jresult ;
28411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28412   float arg2 ;
28413   SwigDirector_ViewImpl *darg = 0;
28414   float result;
28415
28416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28417   arg2 = (float)jarg2;
28418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28419   if (!darg) {
28420     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28421     return 0;
28422   }
28423   {
28424     try {
28425       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
28426     } CALL_CATCH_EXCEPTION(0);
28427   }
28428
28429   jresult = result;
28430   return jresult;
28431 }
28432
28433
28434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
28435   float jresult ;
28436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28437   float arg2 ;
28438   SwigDirector_ViewImpl *darg = 0;
28439   float result;
28440
28441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28442   arg2 = (float)jarg2;
28443   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28444   if (!darg) {
28445     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28446     return 0;
28447   }
28448   {
28449     try {
28450       result = (float)(darg)->GetWidthForHeight(arg2);
28451     } CALL_CATCH_EXCEPTION(0);
28452   }
28453
28454   jresult = result;
28455   return jresult;
28456 }
28457
28458
28459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
28460   float jresult ;
28461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28462   float arg2 ;
28463   SwigDirector_ViewImpl *darg = 0;
28464   float result;
28465
28466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28467   arg2 = (float)jarg2;
28468   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28469   if (!darg) {
28470     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28471     return 0;
28472   }
28473   {
28474     try {
28475       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
28476     } CALL_CATCH_EXCEPTION(0);
28477   }
28478
28479   jresult = result;
28480   return jresult;
28481 }
28482
28483
28484 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
28485   bool jresult ;
28486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28487   Dali::Dimension::Type arg2 ;
28488   SwigDirector_ViewImpl *darg = 0;
28489   bool result;
28490
28491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28492   arg2 = (Dali::Dimension::Type)jarg2;
28493   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28494   if (!darg) {
28495     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28496     return 0;
28497   }
28498   {
28499     try {
28500       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
28501     } CALL_CATCH_EXCEPTION(0);
28502   }
28503
28504   jresult = result;
28505   return jresult;
28506 }
28507
28508
28509 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
28510   bool jresult ;
28511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28512   Dali::Dimension::Type arg2 ;
28513   SwigDirector_ViewImpl *darg = 0;
28514   bool result;
28515
28516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28517   arg2 = (Dali::Dimension::Type)jarg2;
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)->RelayoutDependentOnChildrenSwigPublic(arg2);
28526     } CALL_CATCH_EXCEPTION(0);
28527   }
28528
28529   jresult = result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__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)->RelayoutDependentOnChildren();
28549     } CALL_CATCH_EXCEPTION(0);
28550   }
28551
28552   jresult = result;
28553   return jresult;
28554 }
28555
28556
28557 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
28558   bool jresult ;
28559   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28560   SwigDirector_ViewImpl *darg = 0;
28561   bool result;
28562
28563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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 0;
28568   }
28569   {
28570     try {
28571       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
28572     } CALL_CATCH_EXCEPTION(0);
28573   }
28574
28575   jresult = result;
28576   return jresult;
28577 }
28578
28579
28580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
28581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28582   Dali::Dimension::Type arg2 ;
28583   SwigDirector_ViewImpl *darg = 0;
28584
28585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28586   arg2 = (Dali::Dimension::Type)jarg2;
28587   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28588   if (!darg) {
28589     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28590     return;
28591   }
28592   {
28593     try {
28594       (darg)->OnCalculateRelayoutSize(arg2);
28595     } CALL_CATCH_EXCEPTION();
28596   }
28597
28598 }
28599
28600
28601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
28602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28603   Dali::Dimension::Type arg2 ;
28604   SwigDirector_ViewImpl *darg = 0;
28605
28606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28607   arg2 = (Dali::Dimension::Type)jarg2;
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)->OnCalculateRelayoutSizeSwigPublic(arg2);
28616     } CALL_CATCH_EXCEPTION();
28617   }
28618
28619 }
28620
28621
28622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(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)->OnLayoutNegotiated(arg2,arg3);
28639     } CALL_CATCH_EXCEPTION();
28640   }
28641
28642 }
28643
28644
28645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
28646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28647   float arg2 ;
28648   Dali::Dimension::Type arg3 ;
28649   SwigDirector_ViewImpl *darg = 0;
28650
28651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28652   arg2 = (float)jarg2;
28653   arg3 = (Dali::Dimension::Type)jarg3;
28654   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28655   if (!darg) {
28656     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28657     return;
28658   }
28659   {
28660     try {
28661       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
28662     } CALL_CATCH_EXCEPTION();
28663   }
28664
28665 }
28666
28667
28668 // TODO : SwigDirector_ItemFactory
28669
28670
28671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
28672   void * jresult ;
28673   Dali::Toolkit::ItemFactory *result = 0 ;
28674
28675   {
28676     try {
28677       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
28678     } CALL_CATCH_EXCEPTION(0);
28679   }
28680
28681   jresult = (void *)result;
28682   return jresult;
28683 }
28684
28685 #ifdef __cplusplus
28686 }
28687 #endif