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__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
6475   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6476   Dali::Property::Index arg2 ;
6477   Dali::Property::Value *arg3 = 0 ;
6478
6479   arg1 = (Dali::Property::Map *)jarg1;
6480   arg2 = (Dali::Property::Index)jarg2;
6481   arg3 = (Dali::Property::Value *)jarg3;
6482   if (!arg3) {
6483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6484     return ;
6485   }
6486   {
6487     try {
6488       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
6489     } CALL_CATCH_EXCEPTION();
6490   }
6491
6492 }
6493
6494
6495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
6496   void * jresult ;
6497   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6498   char *arg2 = (char *) 0 ;
6499   Dali::Property::Value *arg3 = 0 ;
6500   Dali::Property::Map *result = 0 ;
6501
6502   arg1 = (Dali::Property::Map *)jarg1;
6503   arg2 = (char *)jarg2;
6504   arg3 = (Dali::Property::Value *)jarg3;
6505   if (!arg3) {
6506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6507     return 0;
6508   }
6509   {
6510     try {
6511       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
6512     } CALL_CATCH_EXCEPTION(0);
6513   }
6514
6515   jresult = (void *)result;
6516   return jresult;
6517 }
6518
6519
6520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
6521   void * jresult ;
6522   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6523   Dali::Property::Index arg2 ;
6524   Dali::Property::Value *arg3 = 0 ;
6525   Dali::Property::Map *result = 0 ;
6526
6527   arg1 = (Dali::Property::Map *)jarg1;
6528   arg2 = (Dali::Property::Index)jarg2;
6529   arg3 = (Dali::Property::Value *)jarg3;
6530   if (!arg3) {
6531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
6532     return 0;
6533   }
6534   {
6535     try {
6536       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
6537     } CALL_CATCH_EXCEPTION(0);
6538   }
6539
6540   jresult = (void *)result;
6541   return jresult;
6542 }
6543
6544
6545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
6546   void * jresult ;
6547   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6548   Dali::Property::Map::SizeType arg2 ;
6549   Dali::Property::Value *result = 0 ;
6550
6551   arg1 = (Dali::Property::Map *)jarg1;
6552   arg2 = (Dali::Property::Map::SizeType)jarg2;
6553   {
6554     try {
6555       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
6556     } CALL_CATCH_EXCEPTION(0);
6557   }
6558
6559   jresult = (void *)result;
6560   return jresult;
6561 }
6562
6563
6564 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
6565   char * jresult ;
6566   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6567   Dali::Property::Map::SizeType arg2 ;
6568   std::string *result = 0 ;
6569
6570   arg1 = (Dali::Property::Map *)jarg1;
6571   arg2 = (Dali::Property::Map::SizeType)jarg2;
6572   {
6573     try {
6574       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
6575     } CALL_CATCH_EXCEPTION(0);
6576   }
6577
6578   jresult = SWIG_csharp_string_callback(result->c_str());
6579   return jresult;
6580 }
6581
6582
6583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
6584   void * jresult ;
6585   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6586   Dali::Property::Map::SizeType arg2 ;
6587   SwigValueWrapper< Dali::Property::Key > result;
6588
6589   arg1 = (Dali::Property::Map *)jarg1;
6590   arg2 = (Dali::Property::Map::SizeType)jarg2;
6591   {
6592     try {
6593       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
6594     } CALL_CATCH_EXCEPTION(0);
6595   }
6596
6597   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
6598   return jresult;
6599 }
6600
6601
6602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
6603   void * jresult ;
6604   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6605   Dali::Property::Map::SizeType arg2 ;
6606   StringValuePair *result = 0 ;
6607
6608   arg1 = (Dali::Property::Map *)jarg1;
6609   arg2 = (Dali::Property::Map::SizeType)jarg2;
6610   {
6611     try {
6612       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
6613     } CALL_CATCH_EXCEPTION(0);
6614   }
6615
6616   jresult = (void *)result;
6617   return jresult;
6618 }
6619
6620
6621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
6622   void * jresult ;
6623   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6624   char *arg2 = (char *) 0 ;
6625   Dali::Property::Value *result = 0 ;
6626
6627   arg1 = (Dali::Property::Map *)jarg1;
6628   arg2 = (char *)jarg2;
6629   {
6630     try {
6631       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
6632     } CALL_CATCH_EXCEPTION(0);
6633   }
6634
6635   jresult = (void *)result;
6636   return jresult;
6637 }
6638
6639
6640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
6641   void * jresult ;
6642   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6643   Dali::Property::Index arg2 ;
6644   Dali::Property::Value *result = 0 ;
6645
6646   arg1 = (Dali::Property::Map *)jarg1;
6647   arg2 = (Dali::Property::Index)jarg2;
6648   {
6649     try {
6650       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
6651     } CALL_CATCH_EXCEPTION(0);
6652   }
6653
6654   jresult = (void *)result;
6655   return jresult;
6656 }
6657
6658
6659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
6660   void * jresult ;
6661   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6662   Dali::Property::Index arg2 ;
6663   std::string *arg3 = 0 ;
6664   Dali::Property::Value *result = 0 ;
6665
6666   arg1 = (Dali::Property::Map *)jarg1;
6667   arg2 = (Dali::Property::Index)jarg2;
6668   if (!jarg3) {
6669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6670     return 0;
6671   }
6672   std::string arg3_str(jarg3);
6673   arg3 = &arg3_str;
6674   {
6675     try {
6676       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
6677     } CALL_CATCH_EXCEPTION(0);
6678   }
6679
6680   jresult = (void *)result;
6681
6682   //argout typemap for const std::string&
6683
6684   return jresult;
6685 }
6686
6687
6688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
6689   void * jresult ;
6690   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6691   std::string *arg2 = 0 ;
6692   Dali::Property::Type arg3 ;
6693   Dali::Property::Value *result = 0 ;
6694
6695   arg1 = (Dali::Property::Map *)jarg1;
6696   if (!jarg2) {
6697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6698     return 0;
6699   }
6700   std::string arg2_str(jarg2);
6701   arg2 = &arg2_str;
6702   arg3 = (Dali::Property::Type)jarg3;
6703   {
6704     try {
6705       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
6706     } CALL_CATCH_EXCEPTION(0);
6707   }
6708
6709   jresult = (void *)result;
6710
6711   //argout typemap for const std::string&
6712
6713   return jresult;
6714 }
6715
6716
6717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
6718   void * jresult ;
6719   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6720   Dali::Property::Index arg2 ;
6721   Dali::Property::Type arg3 ;
6722   Dali::Property::Value *result = 0 ;
6723
6724   arg1 = (Dali::Property::Map *)jarg1;
6725   arg2 = (Dali::Property::Index)jarg2;
6726   arg3 = (Dali::Property::Type)jarg3;
6727   {
6728     try {
6729       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
6730     } CALL_CATCH_EXCEPTION(0);
6731   }
6732
6733   jresult = (void *)result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
6739   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6740
6741   arg1 = (Dali::Property::Map *)jarg1;
6742   {
6743     try {
6744       (arg1)->Clear();
6745     } CALL_CATCH_EXCEPTION();
6746   }
6747
6748 }
6749
6750
6751 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_0(void * map, int key) {
6752   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
6753   Dali::Property::Index intKey = (Dali::Property::Index)key;
6754   bool isRemoved = false;
6755   {
6756     try {
6757       isRemoved = propertyMap->Remove(intKey);
6758     } CALL_CATCH_EXCEPTION(0);
6759   }
6760   return isRemoved;
6761 }
6762
6763
6764 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Map_Remove__SWIG_1(void * map, char * key) {
6765   Dali::Property::Map *propertyMap = (Dali::Property::Map *)map;
6766   std::string strKey(key);
6767   bool isRemoved = false;
6768   {
6769     try {
6770       isRemoved = propertyMap->Remove(strKey);
6771     } CALL_CATCH_EXCEPTION(0);
6772   }
6773   return isRemoved;
6774 }
6775
6776
6777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
6778   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6779   Dali::Property::Map *arg2 = 0 ;
6780
6781   arg1 = (Dali::Property::Map *)jarg1;
6782   arg2 = (Dali::Property::Map *)jarg2;
6783   if (!arg2) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
6785     return ;
6786   }
6787   {
6788     try {
6789       (arg1)->Merge((Dali::Property::Map const &)*arg2);
6790     } CALL_CATCH_EXCEPTION();
6791   }
6792
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
6797   void * jresult ;
6798   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6799   std::string *arg2 = 0 ;
6800   Dali::Property::Value *result = 0 ;
6801
6802   arg1 = (Dali::Property::Map *)jarg1;
6803   if (!jarg2) {
6804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6805     return 0;
6806   }
6807   std::string arg2_str(jarg2);
6808   arg2 = &arg2_str;
6809   {
6810     try {
6811       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
6812     } CALL_CATCH_EXCEPTION(0);
6813   }
6814
6815   jresult = (void *)result;
6816
6817   //argout typemap for const std::string&
6818
6819   return jresult;
6820 }
6821
6822
6823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
6824   void * jresult ;
6825   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6826   Dali::Property::Index arg2 ;
6827   Dali::Property::Value *result = 0 ;
6828
6829   arg1 = (Dali::Property::Map *)jarg1;
6830   arg2 = (Dali::Property::Index)jarg2;
6831   {
6832     try {
6833       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
6834     } CALL_CATCH_EXCEPTION(0);
6835   }
6836
6837   jresult = (void *)result;
6838   return jresult;
6839 }
6840
6841
6842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
6843   void * jresult ;
6844   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
6845   Dali::Property::Map *arg2 = 0 ;
6846   Dali::Property::Map *result = 0 ;
6847
6848   arg1 = (Dali::Property::Map *)jarg1;
6849   arg2 = (Dali::Property::Map *)jarg2;
6850   if (!arg2) {
6851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
6852     return 0;
6853   }
6854   {
6855     try {
6856       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
6857     } CALL_CATCH_EXCEPTION(0);
6858   }
6859
6860   jresult = (void *)result;
6861   return jresult;
6862 }
6863
6864
6865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
6866
6867   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
6868
6869   if (!jarg2) {
6870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
6871     return;
6872   }
6873   std::string arg2_str(jarg2);
6874   std::string* arg2 = &arg2_str;
6875
6876   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
6877
6878   {
6879     try {
6880       arg1->operator[]((std::string const &)*arg2) = *arg3;
6881     } CALL_CATCH_EXCEPTION();
6882   }
6883 }
6884
6885
6886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
6887
6888   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
6889   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
6890   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
6891
6892   {
6893     try {
6894       arg1->operator[](arg2) = *arg3;
6895     } CALL_CATCH_EXCEPTION();
6896   }
6897 }
6898
6899
6900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
6901   void * jresult ;
6902   Dali::Property::Value *result = 0 ;
6903
6904   {
6905     try {
6906       result = (Dali::Property::Value *)new Dali::Property::Value();
6907     } CALL_CATCH_EXCEPTION(0);
6908   }
6909
6910   jresult = (void *)result;
6911   return jresult;
6912 }
6913
6914
6915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(bool jarg1) {
6916   void * jresult ;
6917   bool arg1 ;
6918   Dali::Property::Value *result = 0 ;
6919
6920   arg1 = jarg1 ? true : false;
6921   {
6922     try {
6923       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
6924     } CALL_CATCH_EXCEPTION(0);
6925   }
6926
6927   jresult = (void *)result;
6928   return jresult;
6929 }
6930
6931
6932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
6933   void * jresult ;
6934   int arg1 ;
6935   Dali::Property::Value *result = 0 ;
6936
6937   arg1 = (int)jarg1;
6938   {
6939     try {
6940       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
6941     } CALL_CATCH_EXCEPTION(0);
6942   }
6943
6944   jresult = (void *)result;
6945   return jresult;
6946 }
6947
6948
6949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
6950   void * jresult ;
6951   float arg1 ;
6952   Dali::Property::Value *result = 0 ;
6953
6954   arg1 = (float)jarg1;
6955   {
6956     try {
6957       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
6958     } CALL_CATCH_EXCEPTION(0);
6959   }
6960
6961   jresult = (void *)result;
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
6967   void * jresult ;
6968   Dali::Vector2 *arg1 = 0 ;
6969   Dali::Property::Value *result = 0 ;
6970
6971   arg1 = (Dali::Vector2 *)jarg1;
6972   if (!arg1) {
6973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6974     return 0;
6975   }
6976   {
6977     try {
6978       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
6979     } CALL_CATCH_EXCEPTION(0);
6980   }
6981
6982   jresult = (void *)result;
6983   return jresult;
6984 }
6985
6986
6987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
6988   void * jresult ;
6989   Dali::Vector3 *arg1 = 0 ;
6990   Dali::Property::Value *result = 0 ;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   if (!arg1) {
6994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6995     return 0;
6996   }
6997   {
6998     try {
6999       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
7000     } CALL_CATCH_EXCEPTION(0);
7001   }
7002
7003   jresult = (void *)result;
7004   return jresult;
7005 }
7006
7007
7008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
7009   void * jresult ;
7010   Dali::Vector4 *arg1 = 0 ;
7011   Dali::Property::Value *result = 0 ;
7012
7013   arg1 = (Dali::Vector4 *)jarg1;
7014   if (!arg1) {
7015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7016     return 0;
7017   }
7018   {
7019     try {
7020       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
7021     } CALL_CATCH_EXCEPTION(0);
7022   }
7023
7024   jresult = (void *)result;
7025   return jresult;
7026 }
7027
7028
7029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
7030   void * jresult ;
7031   Dali::Matrix3 *arg1 = 0 ;
7032   Dali::Property::Value *result = 0 ;
7033
7034   arg1 = (Dali::Matrix3 *)jarg1;
7035   if (!arg1) {
7036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
7037     return 0;
7038   }
7039   {
7040     try {
7041       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
7042     } CALL_CATCH_EXCEPTION(0);
7043   }
7044
7045   jresult = (void *)result;
7046   return jresult;
7047 }
7048
7049
7050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
7051   void * jresult ;
7052   Dali::Matrix *arg1 = 0 ;
7053   Dali::Property::Value *result = 0 ;
7054
7055   arg1 = (Dali::Matrix *)jarg1;
7056   if (!arg1) {
7057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
7058     return 0;
7059   }
7060   {
7061     try {
7062       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
7063     } CALL_CATCH_EXCEPTION(0);
7064   }
7065
7066   jresult = (void *)result;
7067   return jresult;
7068 }
7069
7070
7071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
7072   void * jresult ;
7073   Dali::Rect< int > *arg1 = 0 ;
7074   Dali::Property::Value *result = 0 ;
7075
7076   arg1 = (Dali::Rect< int > *)jarg1;
7077   if (!arg1) {
7078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
7079     return 0;
7080   }
7081   {
7082     try {
7083       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
7084     } CALL_CATCH_EXCEPTION(0);
7085   }
7086
7087   jresult = (void *)result;
7088   return jresult;
7089 }
7090
7091
7092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
7093   void * jresult ;
7094   Dali::AngleAxis *arg1 = 0 ;
7095   Dali::Property::Value *result = 0 ;
7096
7097   arg1 = (Dali::AngleAxis *)jarg1;
7098   if (!arg1) {
7099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
7100     return 0;
7101   }
7102   {
7103     try {
7104       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
7105     } CALL_CATCH_EXCEPTION(0);
7106   }
7107
7108   jresult = (void *)result;
7109   return jresult;
7110 }
7111
7112
7113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
7114   void * jresult ;
7115   Dali::Quaternion *arg1 = 0 ;
7116   Dali::Property::Value *result = 0 ;
7117
7118   arg1 = (Dali::Quaternion *)jarg1;
7119   if (!arg1) {
7120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
7121     return 0;
7122   }
7123   {
7124     try {
7125       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
7126     } CALL_CATCH_EXCEPTION(0);
7127   }
7128
7129   jresult = (void *)result;
7130   return jresult;
7131 }
7132
7133
7134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
7135   void * jresult ;
7136   std::string *arg1 = 0 ;
7137   Dali::Property::Value *result = 0 ;
7138
7139   if (!jarg1) {
7140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7141     return 0;
7142   }
7143   std::string arg1_str(jarg1);
7144   arg1 = &arg1_str;
7145   {
7146     try {
7147       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
7148     } CALL_CATCH_EXCEPTION(0);
7149   }
7150
7151   jresult = (void *)result;
7152
7153   //argout typemap for const std::string&
7154
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
7160   void * jresult ;
7161   Dali::Property::Array *arg1 = 0 ;
7162   Dali::Property::Value *result = 0 ;
7163
7164   arg1 = (Dali::Property::Array *)jarg1;
7165   if (!arg1) {
7166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
7167     return 0;
7168   }
7169   {
7170     try {
7171       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
7172     } CALL_CATCH_EXCEPTION(0);
7173   }
7174
7175   jresult = (void *)result;
7176   return jresult;
7177 }
7178
7179
7180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
7181   void * jresult ;
7182   Dali::Property::Map *arg1 = 0 ;
7183   Dali::Property::Value *result = 0 ;
7184
7185   arg1 = (Dali::Property::Map *)jarg1;
7186   if (!arg1) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
7188     return 0;
7189   }
7190   {
7191     try {
7192       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
7193     } CALL_CATCH_EXCEPTION(0);
7194   }
7195
7196   jresult = (void *)result;
7197   return jresult;
7198 }
7199
7200
7201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
7202   void * jresult ;
7203   Extents *arg1 = 0 ;
7204   Dali::Property::Value *result = 0 ;
7205
7206   arg1 = (Extents *)jarg1;
7207   if (!arg1) {
7208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
7209     return 0;
7210   }
7211   {
7212     try {
7213       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
7214     } CALL_CATCH_EXCEPTION(0);
7215   }
7216
7217   jresult = (void*) result;
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
7223   void * jresult ;
7224   Dali::Property::Type arg1 ;
7225   Dali::Property::Value *result = 0 ;
7226
7227   arg1 = (Dali::Property::Type)jarg1;
7228   {
7229     try {
7230       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
7231     } CALL_CATCH_EXCEPTION(0);
7232   }
7233
7234   jresult = (void *)result;
7235   return jresult;
7236 }
7237
7238
7239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
7240   void * jresult ;
7241   Dali::Property::Value *arg1 = 0 ;
7242   Dali::Property::Value *result = 0 ;
7243
7244   arg1 = (Dali::Property::Value *)jarg1;
7245   if (!arg1) {
7246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7247     return 0;
7248   }
7249   {
7250     try {
7251       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
7252     } CALL_CATCH_EXCEPTION(0);
7253   }
7254
7255   jresult = (void *)result;
7256   return jresult;
7257 }
7258
7259
7260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
7261   void * jresult ;
7262   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7263   Dali::Property::Value *arg2 = 0 ;
7264   Dali::Property::Value *result = 0 ;
7265
7266   arg1 = (Dali::Property::Value *)jarg1;
7267   arg2 = (Dali::Property::Value *)jarg2;
7268   if (!arg2) {
7269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7270     return 0;
7271   }
7272   {
7273     try {
7274       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
7275     } CALL_CATCH_EXCEPTION(0);
7276   }
7277
7278   jresult = (void *)result;
7279   return jresult;
7280 }
7281
7282
7283 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_EqualTo(void * jarg1, void * jarg2) {
7284   bool jresult;
7285   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7286   Dali::Property::Value *arg2 = 0 ;
7287   bool result;
7288
7289   arg1 = (Dali::Property::Value *)jarg1;
7290   arg2 = (Dali::Property::Value *)jarg2;
7291   if (!arg2) {
7292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7293     return 0;
7294   }
7295   {
7296     try {
7297       result = (bool)((Dali::Property::Value const *)arg1)->operator ==((Dali::Property::Value const &)*arg2);
7298     } CALL_CATCH_EXCEPTION(0);
7299   }
7300
7301   jresult = result;
7302   return jresult;
7303 }
7304
7305 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_NotEqualTo(void * jarg1, void * jarg2) {
7306   bool jresult;
7307   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7308   Dali::Property::Value *arg2 = 0 ;
7309   bool result;
7310
7311   arg1 = (Dali::Property::Value *)jarg1;
7312   arg2 = (Dali::Property::Value *)jarg2;
7313   if (!arg2) {
7314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
7315     return 0;
7316   }
7317   {
7318     try {
7319       result = (bool)((Dali::Property::Value const *)arg1)->operator !=((Dali::Property::Value const &)*arg2);
7320     } CALL_CATCH_EXCEPTION(0);
7321   }
7322
7323   jresult = result;
7324   return jresult;
7325 }
7326
7327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
7328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7329
7330   arg1 = (Dali::Property::Value *)jarg1;
7331   {
7332     try {
7333       delete arg1;
7334     } CALL_CATCH_EXCEPTION();
7335   }
7336
7337 }
7338
7339
7340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
7341   int jresult ;
7342   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7343   Dali::Property::Type result;
7344
7345   arg1 = (Dali::Property::Value *)jarg1;
7346   {
7347     try {
7348       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
7349     } CALL_CATCH_EXCEPTION(0);
7350   }
7351
7352   jresult = (int)result;
7353   return jresult;
7354 }
7355
7356
7357 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, bool * jarg2) {
7358   bool jresult ;
7359   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7360   bool *arg2 = 0 ;
7361   bool result;
7362
7363   arg1 = (Dali::Property::Value *)jarg1;
7364   arg2 = (bool *)jarg2;
7365   {
7366     try {
7367       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7368     } CALL_CATCH_EXCEPTION(0);
7369   }
7370
7371   jresult = result;
7372   return jresult;
7373 }
7374
7375
7376 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
7377   bool jresult ;
7378   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7379   float *arg2 = 0 ;
7380   bool result;
7381
7382   arg1 = (Dali::Property::Value *)jarg1;
7383   arg2 = (float *)jarg2;
7384   {
7385     try {
7386       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7387     } CALL_CATCH_EXCEPTION(0);
7388   }
7389
7390   jresult = result;
7391   return jresult;
7392 }
7393
7394
7395 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
7396   bool jresult ;
7397   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7398   int *arg2 = 0 ;
7399   bool result;
7400
7401   arg1 = (Dali::Property::Value *)jarg1;
7402   arg2 = (int *)jarg2;
7403   {
7404     try {
7405       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7406     } CALL_CATCH_EXCEPTION(0);
7407   }
7408
7409   jresult = result;
7410   return jresult;
7411 }
7412
7413
7414 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
7415   bool jresult ;
7416   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7417   Dali::Rect< int > *arg2 = 0 ;
7418   bool result;
7419
7420   arg1 = (Dali::Property::Value *)jarg1;
7421   arg2 = (Dali::Rect< int > *)jarg2;
7422   if (!arg2) {
7423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
7424     return 0;
7425   }
7426   {
7427     try {
7428       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7429     } CALL_CATCH_EXCEPTION(0);
7430   }
7431
7432   jresult = result;
7433   return jresult;
7434 }
7435
7436
7437 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
7438   bool jresult ;
7439   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7440   Dali::Vector2 *arg2 = 0 ;
7441   bool result;
7442
7443   arg1 = (Dali::Property::Value *)jarg1;
7444   arg2 = (Dali::Vector2 *)jarg2;
7445   if (!arg2) {
7446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
7447     return 0;
7448   }
7449   {
7450     try {
7451       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7452     } CALL_CATCH_EXCEPTION(0);
7453   }
7454
7455   jresult = result;
7456   return jresult;
7457 }
7458
7459
7460 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
7461   bool jresult ;
7462   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7463   Dali::Vector3 *arg2 = 0 ;
7464   bool result;
7465
7466   arg1 = (Dali::Property::Value *)jarg1;
7467   arg2 = (Dali::Vector3 *)jarg2;
7468   if (!arg2) {
7469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
7470     return 0;
7471   }
7472   {
7473     try {
7474       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7475     } CALL_CATCH_EXCEPTION(0);
7476   }
7477
7478   jresult = result;
7479   return jresult;
7480 }
7481
7482
7483 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
7484   bool jresult ;
7485   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7486   Dali::Vector4 *arg2 = 0 ;
7487   bool result;
7488
7489   arg1 = (Dali::Property::Value *)jarg1;
7490   arg2 = (Dali::Vector4 *)jarg2;
7491   if (!arg2) {
7492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
7493     return 0;
7494   }
7495   {
7496     try {
7497       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7498     } CALL_CATCH_EXCEPTION(0);
7499   }
7500
7501   jresult = result;
7502   return jresult;
7503 }
7504
7505
7506 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
7507   bool jresult ;
7508   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7509   Dali::Matrix3 *arg2 = 0 ;
7510   bool result;
7511
7512   arg1 = (Dali::Property::Value *)jarg1;
7513   arg2 = (Dali::Matrix3 *)jarg2;
7514   if (!arg2) {
7515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
7516     return 0;
7517   }
7518   {
7519     try {
7520       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7521     } CALL_CATCH_EXCEPTION(0);
7522   }
7523
7524   jresult = result;
7525   return jresult;
7526 }
7527
7528
7529 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
7530   bool jresult ;
7531   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7532   Dali::Matrix *arg2 = 0 ;
7533   bool result;
7534
7535   arg1 = (Dali::Property::Value *)jarg1;
7536   arg2 = (Dali::Matrix *)jarg2;
7537   if (!arg2) {
7538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
7539     return 0;
7540   }
7541   {
7542     try {
7543       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7544     } CALL_CATCH_EXCEPTION(0);
7545   }
7546
7547   jresult = result;
7548   return jresult;
7549 }
7550
7551
7552 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
7553   bool jresult ;
7554   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7555   Dali::AngleAxis *arg2 = 0 ;
7556   bool result;
7557
7558   arg1 = (Dali::Property::Value *)jarg1;
7559   arg2 = (Dali::AngleAxis *)jarg2;
7560   if (!arg2) {
7561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
7562     return 0;
7563   }
7564   {
7565     try {
7566       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7567     } CALL_CATCH_EXCEPTION(0);
7568   }
7569
7570   jresult = result;
7571   return jresult;
7572 }
7573
7574
7575 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
7576   bool jresult ;
7577   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7578   Dali::Quaternion *arg2 = 0 ;
7579   bool result;
7580
7581   arg1 = (Dali::Property::Value *)jarg1;
7582   arg2 = (Dali::Quaternion *)jarg2;
7583   if (!arg2) {
7584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
7585     return 0;
7586   }
7587   {
7588     try {
7589       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7590     } CALL_CATCH_EXCEPTION(0);
7591   }
7592
7593   jresult = result;
7594   return jresult;
7595 }
7596
7597
7598 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
7599   bool jresult ;
7600   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7601   std::string *arg2 = 0 ;
7602   bool result;
7603
7604   arg1 = (Dali::Property::Value *)jarg1;
7605
7606   //typemap in
7607   std::string temp;
7608   arg2 = &temp;
7609
7610   {
7611     try {
7612       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7613     } CALL_CATCH_EXCEPTION(0);
7614   }
7615
7616   jresult = result;
7617
7618   //Typemap argout in c++ file.
7619   //This will convert c++ string to c# string
7620   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
7621
7622   return jresult;
7623 }
7624
7625
7626 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
7627   bool jresult ;
7628   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7629   Dali::Property::Array *arg2 = 0 ;
7630   bool result;
7631
7632   arg1 = (Dali::Property::Value *)jarg1;
7633   arg2 = (Dali::Property::Array *)jarg2;
7634   if (!arg2) {
7635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
7636     return 0;
7637   }
7638   {
7639     try {
7640       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7641     } CALL_CATCH_EXCEPTION(0);
7642   }
7643
7644   jresult = result;
7645   return jresult;
7646 }
7647
7648
7649 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
7650   bool jresult ;
7651   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7652   Dali::Property::Map *arg2 = 0 ;
7653   bool result;
7654
7655   arg1 = (Dali::Property::Value *)jarg1;
7656   arg2 = (Dali::Property::Map *)jarg2;
7657   if (!arg2) {
7658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
7659     return 0;
7660   }
7661   {
7662     try {
7663       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7664     } CALL_CATCH_EXCEPTION(0);
7665   }
7666
7667   jresult = result;
7668   return jresult;
7669 }
7670
7671
7672 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
7673   bool jresult ;
7674   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7675   Extents *arg2 = 0 ;
7676   bool result;
7677
7678   arg1 = (Dali::Property::Value *)jarg1;
7679   arg2 = (Extents *)jarg2;
7680   if (!arg2) {
7681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
7682     return 0;
7683   }
7684   {
7685     try {
7686       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
7687     } CALL_CATCH_EXCEPTION(0);
7688   }
7689   jresult = result;
7690   return jresult;
7691 }
7692
7693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
7694   void * jresult ;
7695   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7696   Dali::Property::Array *result = 0 ;
7697
7698   arg1 = (Dali::Property::Value *)jarg1;
7699   {
7700     try {
7701       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
7702     } CALL_CATCH_EXCEPTION(0);
7703   }
7704
7705   jresult = (void *)result;
7706   return jresult;
7707 }
7708
7709
7710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
7711   void * jresult ;
7712   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
7713   Dali::Property::Map *result = 0 ;
7714
7715   arg1 = (Dali::Property::Value *)jarg1;
7716   {
7717     try {
7718       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
7719     } CALL_CATCH_EXCEPTION(0);
7720   }
7721
7722   jresult = (void *)result;
7723   return jresult;
7724 }
7725
7726
7727 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
7728   char * jresult ;
7729   Dali::Property::Type arg1 ;
7730   char *result = 0 ;
7731
7732   arg1 = (Dali::Property::Type)jarg1;
7733   {
7734     try {
7735       result = (char *)Dali::PropertyTypes::GetName(arg1);
7736     } CALL_CATCH_EXCEPTION(0);
7737   }
7738
7739   jresult = SWIG_csharp_string_callback((const char *)result);
7740   return jresult;
7741 }
7742
7743
7744 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
7745   bool jresult ;
7746   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
7747   std::string *arg2 = 0 ;
7748   Dali::Property::Map *arg3 = 0 ;
7749   bool result;
7750
7751   arg1 = (Dali::BaseObject *)jarg1;
7752   if (!jarg2) {
7753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7754     return 0;
7755   }
7756   std::string arg2_str(jarg2);
7757   arg2 = &arg2_str;
7758   arg3 = (Dali::Property::Map *)jarg3;
7759   if (!arg3) {
7760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
7761     return 0;
7762   }
7763   {
7764     try {
7765       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
7766     } CALL_CATCH_EXCEPTION(0);
7767   }
7768
7769   jresult = result;
7770
7771   //argout typemap for const std::string&
7772
7773   return jresult;
7774 }
7775
7776
7777 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
7778   char * jresult ;
7779   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
7780   std::string *result = 0 ;
7781
7782   arg1 = (Dali::BaseObject *)jarg1;
7783   {
7784     try {
7785       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
7786     } CALL_CATCH_EXCEPTION(0);
7787   }
7788
7789   jresult = SWIG_csharp_string_callback(result->c_str());
7790   return jresult;
7791 }
7792
7793
7794 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
7795   bool jresult ;
7796   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
7797   Dali::TypeInfo *arg2 = 0 ;
7798   bool result;
7799
7800   arg1 = (Dali::BaseObject *)jarg1;
7801   arg2 = (Dali::TypeInfo *)jarg2;
7802   if (!arg2) {
7803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
7804     return 0;
7805   }
7806   {
7807     try {
7808       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
7809     } CALL_CATCH_EXCEPTION(0);
7810   }
7811
7812   jresult = result;
7813   return jresult;
7814 }
7815
7816
7817 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
7818   bool jresult ;
7819   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
7820   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
7821   std::string *arg3 = 0 ;
7822   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
7823   bool result;
7824
7825   arg1 = (Dali::BaseObject *)jarg1;
7826   arg2 = (ConnectionTrackerInterface *)jarg2;
7827   if (!jarg3) {
7828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7829     return 0;
7830   }
7831   std::string arg3_str(jarg3);
7832   arg3 = &arg3_str;
7833   arg4 = (FunctorDelegate *)jarg4;
7834   {
7835     try {
7836       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
7837     } CALL_CATCH_EXCEPTION(0);
7838   }
7839
7840   jresult = result;
7841
7842   //argout typemap for const std::string&
7843
7844   return jresult;
7845 }
7846
7847
7848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
7849   void * jresult ;
7850   Dali::BaseHandle *arg1 = 0 ;
7851   Dali::BaseObject *result = 0 ;
7852
7853   arg1 = (Dali::BaseHandle *)jarg1;
7854   if (!arg1) {
7855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
7856     return 0;
7857   }
7858   {
7859     try {
7860       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
7861     } CALL_CATCH_EXCEPTION(0);
7862   }
7863
7864   jresult = (void *)result;
7865   return jresult;
7866 }
7867
7868
7869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
7870   void * jresult ;
7871   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
7872   Dali::BaseHandle *result = 0 ;
7873
7874   arg1 = (Dali::BaseObject *)jarg1;
7875   {
7876     try {
7877       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
7878     } CALL_CATCH_EXCEPTION(0);
7879   }
7880
7881   jresult = (void *)result;
7882   return jresult;
7883 }
7884
7885
7886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
7887   void * jresult ;
7888   Dali::BaseHandle *result = 0 ;
7889
7890   {
7891     try {
7892       result = (Dali::BaseHandle *)new Dali::BaseHandle();
7893     } CALL_CATCH_EXCEPTION(0);
7894   }
7895
7896   jresult = (void *)result;
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
7902   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
7903
7904   arg1 = (Dali::BaseHandle *)jarg1;
7905   {
7906     try {
7907       delete arg1;
7908     } CALL_CATCH_EXCEPTION();
7909   }
7910
7911 }
7912
7913
7914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
7915   void * jresult ;
7916   Dali::BaseHandle *arg1 = 0 ;
7917   Dali::BaseHandle *result = 0 ;
7918
7919   arg1 = (Dali::BaseHandle *)jarg1;
7920   if (!arg1) {
7921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
7922     return 0;
7923   }
7924   {
7925     try {
7926       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
7927     } CALL_CATCH_EXCEPTION(0);
7928   }
7929
7930   jresult = (void *)result;
7931   return jresult;
7932 }
7933
7934
7935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
7936   void * jresult ;
7937   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
7938   Dali::BaseHandle *arg2 = 0 ;
7939   Dali::BaseHandle *result = 0 ;
7940
7941   arg1 = (Dali::BaseHandle *)jarg1;
7942   arg2 = (Dali::BaseHandle *)jarg2;
7943   if (!arg2) {
7944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
7945     return 0;
7946   }
7947   {
7948     try {
7949       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
7950     } CALL_CATCH_EXCEPTION(0);
7951   }
7952
7953   jresult = (void *)result;
7954   return jresult;
7955 }
7956
7957
7958 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
7959   bool jresult ;
7960   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
7961   std::string *arg2 = 0 ;
7962   Dali::Property::Map *arg3 = 0 ;
7963   bool result;
7964
7965   arg1 = (Dali::BaseHandle *)jarg1;
7966   if (!jarg2) {
7967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
7968     return 0;
7969   }
7970   std::string arg2_str(jarg2);
7971   arg2 = &arg2_str;
7972   arg3 = (Dali::Property::Map *)jarg3;
7973   if (!arg3) {
7974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
7975     return 0;
7976   }
7977   {
7978     try {
7979       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
7980     } CALL_CATCH_EXCEPTION(0);
7981   }
7982
7983   jresult = result;
7984
7985   //argout typemap for const std::string&
7986
7987   return jresult;
7988 }
7989
7990
7991 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
7992   char * jresult ;
7993   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
7994   std::string *result = 0 ;
7995
7996   arg1 = (Dali::BaseHandle *)jarg1;
7997   {
7998     try {
7999       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
8000     } CALL_CATCH_EXCEPTION(0);
8001   }
8002
8003   jresult = SWIG_csharp_string_callback(result->c_str());
8004   return jresult;
8005 }
8006
8007
8008 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
8009   bool jresult ;
8010   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8011   Dali::TypeInfo *arg2 = 0 ;
8012   bool result;
8013
8014   arg1 = (Dali::BaseHandle *)jarg1;
8015   arg2 = (Dali::TypeInfo *)jarg2;
8016   if (!arg2) {
8017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
8018     return 0;
8019   }
8020   {
8021     try {
8022       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
8023     } CALL_CATCH_EXCEPTION(0);
8024   }
8025
8026   jresult = result;
8027   return jresult;
8028 }
8029
8030
8031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
8032   void * jresult ;
8033   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8034   Dali::BaseObject *result = 0 ;
8035
8036   arg1 = (Dali::BaseHandle *)jarg1;
8037   {
8038     try {
8039       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
8040     } CALL_CATCH_EXCEPTION(0);
8041   }
8042
8043   jresult = (void *)result;
8044   return jresult;
8045 }
8046
8047
8048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
8049   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8050
8051   arg1 = (Dali::BaseHandle *)jarg1;
8052   {
8053     try {
8054       (arg1)->Reset();
8055     } CALL_CATCH_EXCEPTION();
8056   }
8057
8058 }
8059
8060
8061 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
8062   bool jresult ;
8063   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8064   Dali::BaseHandle *arg2 = 0 ;
8065   bool result;
8066
8067   arg1 = (Dali::BaseHandle *)jarg1;
8068   arg2 = (Dali::BaseHandle *)jarg2;
8069   if (!arg2) {
8070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8071     return 0;
8072   }
8073   {
8074     try {
8075       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
8076     } CALL_CATCH_EXCEPTION(0);
8077   }
8078
8079   jresult = result;
8080   return jresult;
8081 }
8082
8083
8084 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
8085   bool jresult ;
8086   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8087   Dali::BaseHandle *arg2 = 0 ;
8088   bool result;
8089
8090   arg1 = (Dali::BaseHandle *)jarg1;
8091   arg2 = (Dali::BaseHandle *)jarg2;
8092   if (!arg2) {
8093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8094     return 0;
8095   }
8096   {
8097     try {
8098       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
8099     } CALL_CATCH_EXCEPTION(0);
8100   }
8101
8102   jresult = result;
8103   return jresult;
8104 }
8105
8106
8107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
8108   void * jresult ;
8109   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8110   Dali::RefObject *result = 0 ;
8111
8112   arg1 = (Dali::BaseHandle *)jarg1;
8113   {
8114     try {
8115       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
8116     } CALL_CATCH_EXCEPTION(0);
8117   }
8118
8119   jresult = (void *)result;
8120   return jresult;
8121 }
8122
8123
8124 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
8125   bool jresult ;
8126   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8127   bool result;
8128
8129   arg1 = (Dali::BaseHandle *)jarg1;
8130   {
8131     try {
8132       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
8133     } CALL_CATCH_EXCEPTION(0);
8134   }
8135
8136   jresult = result;
8137   return jresult;
8138 }
8139
8140
8141 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
8142   bool jresult ;
8143   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
8144   Dali::BaseHandle *arg2 = 0 ;
8145   bool result;
8146
8147   arg1 = (Dali::BaseHandle *)jarg1;
8148   arg2 = (Dali::BaseHandle *)jarg2;
8149   if (!arg2) {
8150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8151     return 0;
8152   }
8153   {
8154     try {
8155       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
8156     } CALL_CATCH_EXCEPTION(0);
8157   }
8158
8159   jresult = result;
8160   return jresult;
8161 }
8162
8163
8164 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
8165   bool jresult ;
8166   Dali::BaseHandle *arg1 = 0 ;
8167   Dali::BaseHandle *arg2 = 0 ;
8168   bool result;
8169
8170   arg1 = (Dali::BaseHandle *)jarg1;
8171   if (!arg1) {
8172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8173     return 0;
8174   }
8175   arg2 = (Dali::BaseHandle *)jarg2;
8176   if (!arg2) {
8177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
8178     return 0;
8179   }
8180   {
8181     try {
8182       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
8183     } CALL_CATCH_EXCEPTION(0);
8184   }
8185
8186   jresult = result;
8187   return jresult;
8188 }
8189
8190
8191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
8192   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
8193
8194   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
8195   {
8196     try {
8197       delete arg1;
8198     } CALL_CATCH_EXCEPTION();
8199   }
8200
8201 }
8202
8203
8204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
8205   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
8206   SlotObserver *arg2 = (SlotObserver *) 0 ;
8207   CallbackBase *arg3 = (CallbackBase *) 0 ;
8208
8209   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
8210   arg2 = (SlotObserver *)jarg2;
8211   arg3 = (CallbackBase *)jarg3;
8212   {
8213     try {
8214       (arg1)->SignalConnected(arg2,arg3);
8215     } CALL_CATCH_EXCEPTION();
8216   }
8217
8218 }
8219
8220
8221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
8222   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
8223
8224   arg1 = (Dali::SignalObserver *)jarg1;
8225   {
8226     try {
8227       delete arg1;
8228     } CALL_CATCH_EXCEPTION();
8229   }
8230
8231 }
8232
8233
8234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
8235   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
8236   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8237   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8238
8239   arg1 = (Dali::SignalObserver *)jarg1;
8240   arg2 = (Dali::SlotObserver *)jarg2;
8241   arg3 = (Dali::CallbackBase *)jarg3;
8242   {
8243     try {
8244       (arg1)->SignalDisconnected(arg2,arg3);
8245     } CALL_CATCH_EXCEPTION();
8246   }
8247
8248 }
8249
8250
8251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
8252   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
8253
8254   arg1 = (Dali::SlotObserver *)jarg1;
8255   {
8256     try {
8257       delete arg1;
8258     } CALL_CATCH_EXCEPTION();
8259   }
8260
8261 }
8262
8263
8264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
8265   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
8266   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
8267
8268   arg1 = (Dali::SlotObserver *)jarg1;
8269   arg2 = (Dali::CallbackBase *)jarg2;
8270   {
8271     try {
8272       (arg1)->SlotDisconnected(arg2);
8273     } CALL_CATCH_EXCEPTION();
8274   }
8275
8276 }
8277
8278
8279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
8280   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8281
8282   arg1 = (Dali::ConnectionTracker *)jarg1;
8283   {
8284     try {
8285       delete arg1;
8286     } CALL_CATCH_EXCEPTION();
8287   }
8288
8289 }
8290
8291
8292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
8293   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8294
8295   arg1 = (Dali::ConnectionTracker *)jarg1;
8296   {
8297     try {
8298       (arg1)->DisconnectAll();
8299     } CALL_CATCH_EXCEPTION();
8300   }
8301
8302 }
8303
8304
8305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
8306   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8307   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8308   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8309
8310   arg1 = (Dali::ConnectionTracker *)jarg1;
8311   arg2 = (Dali::SlotObserver *)jarg2;
8312   arg3 = (Dali::CallbackBase *)jarg3;
8313   {
8314     try {
8315       (arg1)->SignalConnected(arg2,arg3);
8316     } CALL_CATCH_EXCEPTION();
8317   }
8318
8319 }
8320
8321
8322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
8323   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8324   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
8325   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
8326
8327   arg1 = (Dali::ConnectionTracker *)jarg1;
8328   arg2 = (Dali::SlotObserver *)jarg2;
8329   arg3 = (Dali::CallbackBase *)jarg3;
8330   {
8331     try {
8332       (arg1)->SignalDisconnected(arg2,arg3);
8333     } CALL_CATCH_EXCEPTION();
8334   }
8335
8336 }
8337
8338
8339 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
8340   unsigned long jresult ;
8341   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
8342   std::size_t result;
8343
8344   arg1 = (Dali::ConnectionTracker *)jarg1;
8345   {
8346     try {
8347       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
8348     } CALL_CATCH_EXCEPTION(0);
8349   }
8350
8351   jresult = (unsigned long)result;
8352   return jresult;
8353 }
8354
8355
8356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
8357   void * jresult ;
8358   Dali::ObjectRegistry *result = 0 ;
8359
8360   {
8361     try {
8362       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
8363     } CALL_CATCH_EXCEPTION(0);
8364   }
8365
8366   jresult = (void *)result;
8367   return jresult;
8368 }
8369
8370
8371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
8372   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8373
8374   arg1 = (Dali::ObjectRegistry *)jarg1;
8375   {
8376     try {
8377       delete arg1;
8378     } CALL_CATCH_EXCEPTION();
8379   }
8380
8381 }
8382
8383
8384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
8385   void * jresult ;
8386   Dali::ObjectRegistry *arg1 = 0 ;
8387   Dali::ObjectRegistry *result = 0 ;
8388
8389   arg1 = (Dali::ObjectRegistry *)jarg1;
8390   if (!arg1) {
8391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
8392     return 0;
8393   }
8394   {
8395     try {
8396       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
8397     } CALL_CATCH_EXCEPTION(0);
8398   }
8399
8400   jresult = (void *)result;
8401   return jresult;
8402 }
8403
8404
8405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
8406   void * jresult ;
8407   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8408   Dali::ObjectRegistry *arg2 = 0 ;
8409   Dali::ObjectRegistry *result = 0 ;
8410
8411   arg1 = (Dali::ObjectRegistry *)jarg1;
8412   arg2 = (Dali::ObjectRegistry *)jarg2;
8413   if (!arg2) {
8414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
8415     return 0;
8416   }
8417   {
8418     try {
8419       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
8420     } CALL_CATCH_EXCEPTION(0);
8421   }
8422
8423   jresult = (void *)result;
8424   return jresult;
8425 }
8426
8427
8428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
8429   void * jresult ;
8430   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8431   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
8432
8433   arg1 = (Dali::ObjectRegistry *)jarg1;
8434   {
8435     try {
8436       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
8437     } CALL_CATCH_EXCEPTION(0);
8438   }
8439
8440   jresult = (void *)result;
8441   return jresult;
8442 }
8443
8444
8445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
8446   void * jresult ;
8447   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
8448   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
8449
8450   arg1 = (Dali::ObjectRegistry *)jarg1;
8451   {
8452     try {
8453       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
8454     } CALL_CATCH_EXCEPTION(0);
8455   }
8456
8457   jresult = (void *)result;
8458   return jresult;
8459 }
8460
8461
8462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
8463   void * jresult ;
8464   Dali::PropertyCondition *result = 0 ;
8465
8466   {
8467     try {
8468       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
8469     } CALL_CATCH_EXCEPTION(0);
8470   }
8471
8472   jresult = (void *)result;
8473   return jresult;
8474 }
8475
8476
8477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
8478   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8479
8480   arg1 = (Dali::PropertyCondition *)jarg1;
8481   {
8482     try {
8483       delete arg1;
8484     } CALL_CATCH_EXCEPTION();
8485   }
8486
8487 }
8488
8489
8490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
8491   void * jresult ;
8492   Dali::PropertyCondition *arg1 = 0 ;
8493   Dali::PropertyCondition *result = 0 ;
8494
8495   arg1 = (Dali::PropertyCondition *)jarg1;
8496   if (!arg1) {
8497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
8498     return 0;
8499   }
8500   {
8501     try {
8502       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
8503     } CALL_CATCH_EXCEPTION(0);
8504   }
8505
8506   jresult = (void *)result;
8507   return jresult;
8508 }
8509
8510
8511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
8512   void * jresult ;
8513   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8514   Dali::PropertyCondition *arg2 = 0 ;
8515   Dali::PropertyCondition *result = 0 ;
8516
8517   arg1 = (Dali::PropertyCondition *)jarg1;
8518   arg2 = (Dali::PropertyCondition *)jarg2;
8519   if (!arg2) {
8520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
8521     return 0;
8522   }
8523   {
8524     try {
8525       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
8526     } CALL_CATCH_EXCEPTION(0);
8527   }
8528
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
8535   unsigned long jresult ;
8536   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8537   std::size_t result;
8538
8539   arg1 = (Dali::PropertyCondition *)jarg1;
8540   {
8541     try {
8542       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
8543     } CALL_CATCH_EXCEPTION(0);
8544   }
8545   jresult = (unsigned long)result;
8546   return jresult;
8547 }
8548
8549
8550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
8551   float jresult ;
8552   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
8553   std::size_t arg2 ;
8554   float result;
8555
8556   arg1 = (Dali::PropertyCondition *)jarg1;
8557   arg2 = (std::size_t)jarg2;
8558   {
8559     try {
8560       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
8561     } CALL_CATCH_EXCEPTION(0);
8562   }
8563   jresult = result;
8564   return jresult;
8565 }
8566
8567
8568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
8569   void * jresult ;
8570   float arg1 ;
8571   Dali::PropertyCondition result;
8572
8573   arg1 = (float)jarg1;
8574   {
8575     try {
8576       result = Dali::LessThanCondition(arg1);
8577     } CALL_CATCH_EXCEPTION(0);
8578   }
8579
8580   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8581   return jresult;
8582 }
8583
8584
8585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
8586   void * jresult ;
8587   float arg1 ;
8588   Dali::PropertyCondition result;
8589
8590   arg1 = (float)jarg1;
8591   {
8592     try {
8593       result = Dali::GreaterThanCondition(arg1);
8594     } CALL_CATCH_EXCEPTION(0);
8595   }
8596
8597   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
8603   void * jresult ;
8604   float arg1 ;
8605   float arg2 ;
8606   Dali::PropertyCondition result;
8607
8608   arg1 = (float)jarg1;
8609   arg2 = (float)jarg2;
8610   {
8611     try {
8612       result = Dali::InsideCondition(arg1,arg2);
8613     } CALL_CATCH_EXCEPTION(0);
8614   }
8615
8616   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8617   return jresult;
8618 }
8619
8620
8621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
8622   void * jresult ;
8623   float arg1 ;
8624   float arg2 ;
8625   Dali::PropertyCondition result;
8626
8627   arg1 = (float)jarg1;
8628   arg2 = (float)jarg2;
8629   {
8630     try {
8631       result = Dali::OutsideCondition(arg1,arg2);
8632     } CALL_CATCH_EXCEPTION(0);
8633   }
8634
8635   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8636   return jresult;
8637 }
8638
8639
8640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
8641   void * jresult ;
8642   float arg1 ;
8643   float arg2 ;
8644   Dali::PropertyCondition result;
8645
8646   arg1 = (float)jarg1;
8647   arg2 = (float)jarg2;
8648   {
8649     try {
8650       result = Dali::StepCondition(arg1,arg2);
8651     } CALL_CATCH_EXCEPTION(0);
8652   }
8653
8654   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8655   return jresult;
8656 }
8657
8658
8659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
8660   void * jresult ;
8661   float arg1 ;
8662   Dali::PropertyCondition result;
8663
8664   arg1 = (float)jarg1;
8665   {
8666     try {
8667       result = Dali::StepCondition(arg1);
8668     } CALL_CATCH_EXCEPTION(0);
8669   }
8670
8671   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8672   return jresult;
8673 }
8674
8675
8676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
8677   void * jresult ;
8678   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
8679   Dali::PropertyCondition result;
8680
8681   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
8682   if (!arg1) {
8683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
8684     return 0;
8685   }
8686   {
8687     try {
8688       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
8689     } CALL_CATCH_EXCEPTION(0);
8690   }
8691
8692   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8693   return jresult;
8694 }
8695
8696
8697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
8698   void * jresult ;
8699   Dali::PropertyNotification *result = 0 ;
8700
8701   {
8702     try {
8703       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
8704     } CALL_CATCH_EXCEPTION(0);
8705   }
8706
8707   jresult = (void *)result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
8713   void * jresult ;
8714   Dali::BaseHandle arg1 ;
8715   Dali::BaseHandle *argp1 ;
8716   Dali::PropertyNotification result;
8717
8718   argp1 = (Dali::BaseHandle *)jarg1;
8719   if (!argp1) {
8720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
8721     return 0;
8722   }
8723   arg1 = *argp1;
8724   {
8725     try {
8726       result = Dali::PropertyNotification::DownCast(arg1);
8727     } CALL_CATCH_EXCEPTION(0);
8728   }
8729
8730   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
8736   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8737
8738   arg1 = (Dali::PropertyNotification *)jarg1;
8739   {
8740     try {
8741       delete arg1;
8742     } CALL_CATCH_EXCEPTION();
8743   }
8744
8745 }
8746
8747
8748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
8749   void * jresult ;
8750   Dali::PropertyNotification *arg1 = 0 ;
8751   Dali::PropertyNotification *result = 0 ;
8752
8753   arg1 = (Dali::PropertyNotification *)jarg1;
8754   if (!arg1) {
8755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
8756     return 0;
8757   }
8758   {
8759     try {
8760       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
8761     } CALL_CATCH_EXCEPTION(0);
8762   }
8763
8764   jresult = (void *)result;
8765   return jresult;
8766 }
8767
8768
8769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
8770   void * jresult ;
8771   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8772   Dali::PropertyNotification *arg2 = 0 ;
8773   Dali::PropertyNotification *result = 0 ;
8774
8775   arg1 = (Dali::PropertyNotification *)jarg1;
8776   arg2 = (Dali::PropertyNotification *)jarg2;
8777   if (!arg2) {
8778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
8779     return 0;
8780   }
8781   {
8782     try {
8783       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
8784     } CALL_CATCH_EXCEPTION(0);
8785   }
8786
8787   jresult = (void *)result;
8788   return jresult;
8789 }
8790
8791
8792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
8793   void * jresult ;
8794   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8795   Dali::PropertyCondition result;
8796
8797   arg1 = (Dali::PropertyNotification *)jarg1;
8798   {
8799     try {
8800       result = (arg1)->GetCondition();
8801     } CALL_CATCH_EXCEPTION(0);
8802   }
8803
8804   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
8805   return jresult;
8806 }
8807
8808
8809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
8810   void * jresult ;
8811   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8812   Dali::Handle result;
8813
8814   arg1 = (Dali::PropertyNotification *)jarg1;
8815   {
8816     try {
8817       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
8818     } CALL_CATCH_EXCEPTION(0);
8819   }
8820
8821   jresult = new Dali::Handle((const Dali::Handle &)result);
8822   return jresult;
8823 }
8824
8825
8826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
8827   int jresult ;
8828   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8829   Dali::Property::Index result;
8830
8831   arg1 = (Dali::PropertyNotification *)jarg1;
8832   {
8833     try {
8834       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
8835     } CALL_CATCH_EXCEPTION(0);
8836   }
8837
8838   jresult = result;
8839   return jresult;
8840 }
8841
8842
8843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
8844   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8845   Dali::PropertyNotification::NotifyMode arg2 ;
8846
8847   arg1 = (Dali::PropertyNotification *)jarg1;
8848   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
8849   {
8850     try {
8851       (arg1)->SetNotifyMode(arg2);
8852     } CALL_CATCH_EXCEPTION();
8853   }
8854
8855 }
8856
8857
8858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
8859   int jresult ;
8860   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8861   Dali::PropertyNotification::NotifyMode result;
8862
8863   arg1 = (Dali::PropertyNotification *)jarg1;
8864   {
8865     try {
8866       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
8867     } CALL_CATCH_EXCEPTION(0);
8868   }
8869
8870   jresult = (int)result;
8871   return jresult;
8872 }
8873
8874
8875 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
8876   bool jresult ;
8877   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8878   bool result;
8879
8880   arg1 = (Dali::PropertyNotification *)jarg1;
8881   {
8882     try {
8883       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
8884     } CALL_CATCH_EXCEPTION(0);
8885   }
8886
8887   jresult = result;
8888   return jresult;
8889 }
8890
8891
8892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
8893   void * jresult ;
8894   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
8895   Dali::PropertyNotifySignalType *result = 0 ;
8896
8897   arg1 = (Dali::PropertyNotification *)jarg1;
8898   {
8899     try {
8900       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
8901     } CALL_CATCH_EXCEPTION(0);
8902   }
8903
8904   jresult = (void *)result;
8905   return jresult;
8906 }
8907
8908
8909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
8910   void * jresult ;
8911   Dali::Handle *result = 0 ;
8912
8913   {
8914     try {
8915       result = (Dali::Handle *)new Dali::Handle();
8916     } CALL_CATCH_EXCEPTION(0);
8917   }
8918
8919   jresult = (void *)result;
8920   return jresult;
8921 }
8922
8923
8924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
8925   void * jresult ;
8926   Dali::Handle result;
8927
8928   {
8929     try {
8930       result = Dali::Handle::New();
8931     } CALL_CATCH_EXCEPTION(0);
8932   }
8933
8934   jresult = new Dali::Handle((const Dali::Handle &)result);
8935   return jresult;
8936 }
8937
8938
8939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
8940   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
8941
8942   arg1 = (Dali::Handle *)jarg1;
8943   {
8944     try {
8945       delete arg1;
8946     } CALL_CATCH_EXCEPTION();
8947   }
8948
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
8953   void * jresult ;
8954   Dali::Handle *arg1 = 0 ;
8955   Dali::Handle *result = 0 ;
8956
8957   arg1 = (Dali::Handle *)jarg1;
8958   if (!arg1) {
8959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
8960     return 0;
8961   }
8962   {
8963     try {
8964       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
8965     } CALL_CATCH_EXCEPTION(0);
8966   }
8967
8968   jresult = (void *)result;
8969   return jresult;
8970 }
8971
8972
8973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
8974   void * jresult ;
8975   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
8976   Dali::Handle *arg2 = 0 ;
8977   Dali::Handle *result = 0 ;
8978
8979   arg1 = (Dali::Handle *)jarg1;
8980   arg2 = (Dali::Handle *)jarg2;
8981   if (!arg2) {
8982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
8983     return 0;
8984   }
8985   {
8986     try {
8987       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
8988     } CALL_CATCH_EXCEPTION(0);
8989   }
8990
8991   jresult = (void *)result;
8992   return jresult;
8993 }
8994
8995
8996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
8997   void * jresult ;
8998   Dali::BaseHandle arg1 ;
8999   Dali::BaseHandle *argp1 ;
9000   Dali::Handle result;
9001
9002   argp1 = (Dali::BaseHandle *)jarg1;
9003   if (!argp1) {
9004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
9005     return 0;
9006   }
9007   arg1 = *argp1;
9008   {
9009     try {
9010       result = Dali::Handle::DownCast(arg1);
9011     } CALL_CATCH_EXCEPTION(0);
9012   }
9013
9014   jresult = new Dali::Handle((const Dali::Handle &)result);
9015   return jresult;
9016 }
9017
9018
9019 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
9020   bool jresult ;
9021   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9022   Dali::Handle::Capability arg2 ;
9023   bool result;
9024
9025   arg1 = (Dali::Handle *)jarg1;
9026   arg2 = (Dali::Handle::Capability)jarg2;
9027   {
9028     try {
9029       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
9030     } CALL_CATCH_EXCEPTION(0);
9031   }
9032
9033   jresult = result;
9034   return jresult;
9035 }
9036
9037
9038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
9039   unsigned int jresult ;
9040   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9041   unsigned int result;
9042
9043   arg1 = (Dali::Handle *)jarg1;
9044   {
9045     try {
9046       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
9047     } CALL_CATCH_EXCEPTION(0);
9048   }
9049
9050   jresult = result;
9051   return jresult;
9052 }
9053
9054
9055 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
9056   char * jresult ;
9057   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9058   Dali::Property::Index arg2 ;
9059   std::string result;
9060
9061   arg1 = (Dali::Handle *)jarg1;
9062   arg2 = (Dali::Property::Index)jarg2;
9063   {
9064     try {
9065       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
9066     } CALL_CATCH_EXCEPTION(0);
9067   }
9068
9069   jresult = SWIG_csharp_string_callback((&result)->c_str());
9070   return jresult;
9071 }
9072
9073
9074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
9075   int jresult ;
9076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9077   std::string *arg2 = 0 ;
9078   Dali::Property::Index result;
9079
9080   arg1 = (Dali::Handle *)jarg1;
9081   if (!jarg2) {
9082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9083     return 0;
9084   }
9085   std::string arg2_str(jarg2);
9086   arg2 = &arg2_str;
9087   {
9088     try {
9089       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
9090     } CALL_CATCH_EXCEPTION(0);
9091   }
9092
9093   jresult = result;
9094
9095   //argout typemap for const std::string&
9096
9097   return jresult;
9098 }
9099
9100
9101 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
9102   bool jresult ;
9103   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9104   Dali::Property::Index arg2 ;
9105   bool result;
9106
9107   arg1 = (Dali::Handle *)jarg1;
9108   arg2 = (Dali::Property::Index)jarg2;
9109   {
9110     try {
9111       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
9112     } CALL_CATCH_EXCEPTION(0);
9113   }
9114
9115   jresult = result;
9116   return jresult;
9117 }
9118
9119
9120 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
9121   bool jresult ;
9122   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9123   Dali::Property::Index arg2 ;
9124   bool result;
9125
9126   arg1 = (Dali::Handle *)jarg1;
9127   arg2 = (Dali::Property::Index)jarg2;
9128   {
9129     try {
9130       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
9131     } CALL_CATCH_EXCEPTION(0);
9132   }
9133
9134   jresult = result;
9135   return jresult;
9136 }
9137
9138
9139 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
9140   bool jresult ;
9141   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9142   Dali::Property::Index arg2 ;
9143   bool result;
9144
9145   arg1 = (Dali::Handle *)jarg1;
9146   arg2 = (Dali::Property::Index)jarg2;
9147   {
9148     try {
9149       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
9150     } CALL_CATCH_EXCEPTION(0);
9151   }
9152
9153   jresult = result;
9154   return jresult;
9155 }
9156
9157
9158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
9159   int jresult ;
9160   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9161   Dali::Property::Index arg2 ;
9162   Dali::Property::Type result;
9163
9164   arg1 = (Dali::Handle *)jarg1;
9165   arg2 = (Dali::Property::Index)jarg2;
9166   {
9167     try {
9168       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
9169     } CALL_CATCH_EXCEPTION(0);
9170   }
9171
9172   jresult = (int)result;
9173   return jresult;
9174 }
9175
9176
9177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
9178   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9179   Dali::Property::Index arg2 ;
9180   Dali::Property::Value *arg3 = 0 ;
9181
9182   arg1 = (Dali::Handle *)jarg1;
9183   arg2 = (Dali::Property::Index)jarg2;
9184   arg3 = (Dali::Property::Value *)jarg3;
9185   if (!arg3) {
9186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9187     return ;
9188   }
9189   {
9190     try {
9191       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
9192     } CALL_CATCH_EXCEPTION();
9193   }
9194
9195 }
9196
9197
9198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
9199   int jresult ;
9200   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9201   std::string *arg2 = 0 ;
9202   Dali::Property::Value *arg3 = 0 ;
9203   Dali::Property::Index result;
9204
9205   arg1 = (Dali::Handle *)jarg1;
9206   if (!jarg2) {
9207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9208     return 0;
9209   }
9210   std::string arg2_str(jarg2);
9211   arg2 = &arg2_str;
9212   arg3 = (Dali::Property::Value *)jarg3;
9213   if (!arg3) {
9214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9215     return 0;
9216   }
9217   {
9218     try {
9219       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
9220     } CALL_CATCH_EXCEPTION(0);
9221   }
9222
9223   jresult = result;
9224
9225   //argout typemap for const std::string&
9226
9227   return jresult;
9228 }
9229
9230
9231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
9232   int jresult ;
9233   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9234   std::string *arg2 = 0 ;
9235   Dali::Property::Value *arg3 = 0 ;
9236   Dali::Property::AccessMode arg4 ;
9237   Dali::Property::Index result;
9238
9239   arg1 = (Dali::Handle *)jarg1;
9240   if (!jarg2) {
9241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9242     return 0;
9243   }
9244   std::string arg2_str(jarg2);
9245   arg2 = &arg2_str;
9246   arg3 = (Dali::Property::Value *)jarg3;
9247   if (!arg3) {
9248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
9249     return 0;
9250   }
9251   arg4 = (Dali::Property::AccessMode)jarg4;
9252   {
9253     try {
9254       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
9255     } CALL_CATCH_EXCEPTION(0);
9256   }
9257
9258   jresult = result;
9259
9260   //argout typemap for const std::string&
9261
9262   return jresult;
9263 }
9264
9265
9266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
9267   void * jresult ;
9268   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9269   Dali::Property::Index arg2 ;
9270   Dali::Property::Value result;
9271
9272   arg1 = (Dali::Handle *)jarg1;
9273   arg2 = (Dali::Property::Index)jarg2;
9274   {
9275     try {
9276       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
9277     } CALL_CATCH_EXCEPTION(0);
9278   }
9279
9280   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
9281   return jresult;
9282 }
9283
9284
9285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetCurrentProperty(void * jarg1, int jarg2) {
9286   void * jresult ;
9287   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9288   Dali::Property::Index arg2 ;
9289   Dali::Property::Value result;
9290
9291   arg1 = (Dali::Handle *)jarg1;
9292   arg2 = (Dali::Property::Index)jarg2;
9293   {
9294     try {
9295       result = ((Dali::Handle const *)arg1)->GetCurrentProperty(arg2);
9296     } CALL_CATCH_EXCEPTION(0);
9297   }
9298
9299   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
9300   return jresult;
9301 }
9302
9303
9304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
9305   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9306   Dali::Property::IndexContainer *arg2 = 0 ;
9307
9308   arg1 = (Dali::Handle *)jarg1;
9309   arg2 = (Dali::Property::IndexContainer *)jarg2;
9310   if (!arg2) {
9311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
9312     return ;
9313   }
9314   {
9315     try {
9316       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
9317     } CALL_CATCH_EXCEPTION();
9318   }
9319
9320 }
9321
9322
9323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
9324   void * jresult ;
9325   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9326   Dali::Property::Index arg2 ;
9327   Dali::PropertyCondition *arg3 = 0 ;
9328   Dali::PropertyNotification result;
9329
9330   arg1 = (Dali::Handle *)jarg1;
9331   arg2 = (Dali::Property::Index)jarg2;
9332   arg3 = (Dali::PropertyCondition *)jarg3;
9333   if (!arg3) {
9334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
9335     return 0;
9336   }
9337   {
9338     try {
9339       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
9340     } CALL_CATCH_EXCEPTION(0);
9341   }
9342
9343   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9344   return jresult;
9345 }
9346
9347
9348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
9349   void * jresult ;
9350   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9351   Dali::Property::Index arg2 ;
9352   int arg3 ;
9353   Dali::PropertyCondition *arg4 = 0 ;
9354   Dali::PropertyNotification result;
9355
9356   arg1 = (Dali::Handle *)jarg1;
9357   arg2 = (Dali::Property::Index)jarg2;
9358   arg3 = (int)jarg3;
9359   arg4 = (Dali::PropertyCondition *)jarg4;
9360   if (!arg4) {
9361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
9362     return 0;
9363   }
9364   {
9365     try {
9366       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
9367     } CALL_CATCH_EXCEPTION(0);
9368   }
9369
9370   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
9371   return jresult;
9372 }
9373
9374
9375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
9376   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9377   Dali::PropertyNotification arg2 ;
9378   Dali::PropertyNotification *argp2 ;
9379
9380   arg1 = (Dali::Handle *)jarg1;
9381   argp2 = (Dali::PropertyNotification *)jarg2;
9382   if (!argp2) {
9383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
9384     return ;
9385   }
9386   arg2 = *argp2;
9387   {
9388     try {
9389       (arg1)->RemovePropertyNotification(arg2);
9390     } CALL_CATCH_EXCEPTION();
9391   }
9392
9393 }
9394
9395
9396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
9397   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9398
9399   arg1 = (Dali::Handle *)jarg1;
9400   {
9401     try {
9402       (arg1)->RemovePropertyNotifications();
9403     } CALL_CATCH_EXCEPTION();
9404   }
9405
9406 }
9407
9408
9409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
9410   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9411
9412   arg1 = (Dali::Handle *)jarg1;
9413   {
9414     try {
9415       (arg1)->RemoveConstraints();
9416     } CALL_CATCH_EXCEPTION();
9417   }
9418
9419 }
9420
9421
9422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
9423   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
9424   unsigned int arg2 ;
9425
9426   arg1 = (Dali::Handle *)jarg1;
9427   arg2 = (unsigned int)jarg2;
9428   {
9429     try {
9430       (arg1)->RemoveConstraints(arg2);
9431     } CALL_CATCH_EXCEPTION();
9432   }
9433
9434 }
9435
9436
9437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
9438   void * jresult ;
9439   Dali::Handle result;
9440
9441   {
9442     try {
9443       result = Dali::WeightObject::New();
9444     } CALL_CATCH_EXCEPTION(0);
9445   }
9446
9447   jresult = new Dali::Handle((const Dali::Handle &)result);
9448   return jresult;
9449 }
9450
9451
9452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
9453   void * jresult ;
9454   Dali::TypeInfo *result = 0 ;
9455
9456   {
9457     try {
9458       result = (Dali::TypeInfo *)new Dali::TypeInfo();
9459     } CALL_CATCH_EXCEPTION(0);
9460   }
9461
9462   jresult = (void *)result;
9463   return jresult;
9464 }
9465
9466
9467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
9468   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9469
9470   arg1 = (Dali::TypeInfo *)jarg1;
9471   {
9472     try {
9473       delete arg1;
9474     } CALL_CATCH_EXCEPTION();
9475   }
9476
9477 }
9478
9479
9480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
9481   void * jresult ;
9482   Dali::TypeInfo *arg1 = 0 ;
9483   Dali::TypeInfo *result = 0 ;
9484
9485   arg1 = (Dali::TypeInfo *)jarg1;
9486   if (!arg1) {
9487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
9488     return 0;
9489   }
9490   {
9491     try {
9492       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
9493     } CALL_CATCH_EXCEPTION(0);
9494   }
9495
9496   jresult = (void *)result;
9497   return jresult;
9498 }
9499
9500
9501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
9502   void * jresult ;
9503   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9504   Dali::TypeInfo *arg2 = 0 ;
9505   Dali::TypeInfo *result = 0 ;
9506
9507   arg1 = (Dali::TypeInfo *)jarg1;
9508   arg2 = (Dali::TypeInfo *)jarg2;
9509   if (!arg2) {
9510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
9511     return 0;
9512   }
9513   {
9514     try {
9515       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
9516     } CALL_CATCH_EXCEPTION(0);
9517   }
9518
9519   jresult = (void *)result;
9520   return jresult;
9521 }
9522
9523
9524 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
9525   char * jresult ;
9526   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9527   std::string *result = 0 ;
9528
9529   arg1 = (Dali::TypeInfo *)jarg1;
9530   {
9531     try {
9532       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
9533     } CALL_CATCH_EXCEPTION(0);
9534   }
9535
9536   jresult = SWIG_csharp_string_callback(result->c_str());
9537   return jresult;
9538 }
9539
9540
9541 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
9542   char * jresult ;
9543   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9544   std::string *result = 0 ;
9545
9546   arg1 = (Dali::TypeInfo *)jarg1;
9547   {
9548     try {
9549       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
9550     } CALL_CATCH_EXCEPTION(0);
9551   }
9552
9553   jresult = SWIG_csharp_string_callback(result->c_str());
9554   return jresult;
9555 }
9556
9557
9558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
9559   void * jresult ;
9560   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9561   Dali::BaseHandle result;
9562
9563   arg1 = (Dali::TypeInfo *)jarg1;
9564   {
9565     try {
9566       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
9567     } CALL_CATCH_EXCEPTION(0);
9568   }
9569
9570   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
9571   return jresult;
9572 }
9573
9574
9575 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
9576   unsigned long jresult ;
9577   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9578   size_t result;
9579
9580   arg1 = (Dali::TypeInfo *)jarg1;
9581   {
9582     try {
9583       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
9584     } CALL_CATCH_EXCEPTION(0);
9585   }
9586
9587   jresult = (unsigned long)result;
9588   return jresult;
9589 }
9590
9591
9592 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
9593   char * jresult ;
9594   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9595   size_t arg2 ;
9596   std::string result;
9597
9598   arg1 = (Dali::TypeInfo *)jarg1;
9599   arg2 = (size_t)jarg2;
9600   {
9601     try {
9602       result = (arg1)->GetActionName(arg2);
9603     } CALL_CATCH_EXCEPTION(0);
9604   }
9605
9606   jresult = SWIG_csharp_string_callback((&result)->c_str());
9607   return jresult;
9608 }
9609
9610
9611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
9612   unsigned long jresult ;
9613   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9614   size_t result;
9615
9616   arg1 = (Dali::TypeInfo *)jarg1;
9617   {
9618     try {
9619       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
9620     } CALL_CATCH_EXCEPTION(0);
9621   }
9622
9623   jresult = (unsigned long)result;
9624   return jresult;
9625 }
9626
9627
9628 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
9629   char * jresult ;
9630   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9631   size_t arg2 ;
9632   std::string result;
9633
9634   arg1 = (Dali::TypeInfo *)jarg1;
9635   arg2 = (size_t)jarg2;
9636   {
9637     try {
9638       result = (arg1)->GetSignalName(arg2);
9639     } CALL_CATCH_EXCEPTION(0);
9640   }
9641
9642   jresult = SWIG_csharp_string_callback((&result)->c_str());
9643   return jresult;
9644 }
9645
9646
9647 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
9648   unsigned long jresult ;
9649   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9650   size_t result;
9651
9652   arg1 = (Dali::TypeInfo *)jarg1;
9653   {
9654     try {
9655       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
9656     } CALL_CATCH_EXCEPTION(0);
9657   }
9658
9659   jresult = (unsigned long)result;
9660   return jresult;
9661 }
9662
9663
9664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
9665   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9666   Dali::Property::IndexContainer *arg2 = 0 ;
9667
9668   arg1 = (Dali::TypeInfo *)jarg1;
9669   arg2 = (Dali::Property::IndexContainer *)jarg2;
9670   if (!arg2) {
9671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
9672     return ;
9673   }
9674   {
9675     try {
9676       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
9677     } CALL_CATCH_EXCEPTION();
9678   }
9679
9680 }
9681
9682
9683 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
9684   char * jresult ;
9685   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
9686   Dali::Property::Index arg2 ;
9687   std::string_view result;
9688
9689   arg1 = (Dali::TypeInfo *)jarg1;
9690   arg2 = (Dali::Property::Index)jarg2;
9691   {
9692     try {
9693       result = ((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
9694     } CALL_CATCH_EXCEPTION(0);
9695   }
9696
9697   jresult = SWIG_csharp_string_callback(result.data());
9698   return jresult;
9699 }
9700
9701
9702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
9703   void * jresult ;
9704   Dali::TypeRegistry result;
9705
9706   {
9707     try {
9708       result = Dali::TypeRegistry::Get();
9709     } CALL_CATCH_EXCEPTION(0);
9710   }
9711
9712   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
9718   void * jresult ;
9719   Dali::TypeRegistry *result = 0 ;
9720
9721   {
9722     try {
9723       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
9724     } CALL_CATCH_EXCEPTION(0);
9725   }
9726
9727   jresult = (void *)result;
9728   return jresult;
9729 }
9730
9731
9732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
9733   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
9734
9735   arg1 = (Dali::TypeRegistry *)jarg1;
9736   {
9737     try {
9738       delete arg1;
9739     } CALL_CATCH_EXCEPTION();
9740   }
9741
9742 }
9743
9744
9745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
9746   void * jresult ;
9747   Dali::TypeRegistry *arg1 = 0 ;
9748   Dali::TypeRegistry *result = 0 ;
9749
9750   arg1 = (Dali::TypeRegistry *)jarg1;
9751   if (!arg1) {
9752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
9753     return 0;
9754   }
9755   {
9756     try {
9757       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
9758     } CALL_CATCH_EXCEPTION(0);
9759   }
9760
9761   jresult = (void *)result;
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
9767   void * jresult ;
9768   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
9769   Dali::TypeRegistry *arg2 = 0 ;
9770   Dali::TypeRegistry *result = 0 ;
9771
9772   arg1 = (Dali::TypeRegistry *)jarg1;
9773   arg2 = (Dali::TypeRegistry *)jarg2;
9774   if (!arg2) {
9775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
9776     return 0;
9777   }
9778   {
9779     try {
9780       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
9781     } CALL_CATCH_EXCEPTION(0);
9782   }
9783
9784   jresult = (void *)result;
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
9790   void * jresult ;
9791   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
9792   std::string *arg2 = 0 ;
9793   Dali::TypeInfo result;
9794
9795   arg1 = (Dali::TypeRegistry *)jarg1;
9796   if (!jarg2) {
9797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9798     return 0;
9799   }
9800   std::string arg2_str(jarg2);
9801   arg2 = &arg2_str;
9802   {
9803     try {
9804       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
9805     } CALL_CATCH_EXCEPTION(0);
9806   }
9807
9808   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
9809
9810   //argout typemap for const std::string&
9811
9812   return jresult;
9813 }
9814
9815
9816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
9817   void * jresult ;
9818   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
9819   std::type_info *arg2 = 0 ;
9820   Dali::TypeInfo result;
9821
9822   arg1 = (Dali::TypeRegistry *)jarg1;
9823   arg2 = (std::type_info *)jarg2;
9824   if (!arg2) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
9826     return 0;
9827   }
9828   {
9829     try {
9830       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
9831     } CALL_CATCH_EXCEPTION(0);
9832   }
9833
9834   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
9835   return jresult;
9836 }
9837
9838
9839 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
9840   unsigned long jresult ;
9841   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
9842   size_t result;
9843
9844   arg1 = (Dali::TypeRegistry *)jarg1;
9845   {
9846     try {
9847       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
9848     } CALL_CATCH_EXCEPTION(0);
9849   }
9850
9851   jresult = (unsigned long)result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
9857   char * jresult ;
9858   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
9859   size_t arg2 ;
9860   std::string result;
9861
9862   arg1 = (Dali::TypeRegistry *)jarg1;
9863   arg2 = (size_t)jarg2;
9864   {
9865     try {
9866       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
9867     } CALL_CATCH_EXCEPTION(0);
9868   }
9869
9870   jresult = SWIG_csharp_string_callback((&result)->c_str());
9871   return jresult;
9872 }
9873
9874
9875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
9876   void * jresult ;
9877   std::type_info *arg1 = 0 ;
9878   std::type_info *arg2 = 0 ;
9879   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
9880   Dali::TypeRegistration *result = 0 ;
9881
9882   arg1 = (std::type_info *)jarg1;
9883   if (!arg1) {
9884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
9885     return 0;
9886   }
9887   arg2 = (std::type_info *)jarg2;
9888   if (!arg2) {
9889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
9890     return 0;
9891   }
9892   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
9893   {
9894     try {
9895       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
9896     } CALL_CATCH_EXCEPTION(0);
9897   }
9898
9899   jresult = (void *)result;
9900   return jresult;
9901 }
9902
9903
9904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, bool jarg4) {
9905   void * jresult ;
9906   std::type_info *arg1 = 0 ;
9907   std::type_info *arg2 = 0 ;
9908   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
9909   bool arg4 ;
9910   Dali::TypeRegistration *result = 0 ;
9911
9912   arg1 = (std::type_info *)jarg1;
9913   if (!arg1) {
9914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
9915     return 0;
9916   }
9917   arg2 = (std::type_info *)jarg2;
9918   if (!arg2) {
9919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
9920     return 0;
9921   }
9922   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
9923   arg4 = jarg4 ? true : false;
9924   {
9925     try {
9926       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
9927     } CALL_CATCH_EXCEPTION(0);
9928   }
9929
9930   jresult = (void *)result;
9931   return jresult;
9932 }
9933
9934
9935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
9936   void * jresult ;
9937   std::string *arg1 = 0 ;
9938   std::type_info *arg2 = 0 ;
9939   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
9940   Dali::TypeRegistration *result = 0 ;
9941
9942   if (!jarg1) {
9943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9944     return 0;
9945   }
9946   std::string arg1_str(jarg1);
9947   arg1 = &arg1_str;
9948   arg2 = (std::type_info *)jarg2;
9949   if (!arg2) {
9950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
9951     return 0;
9952   }
9953   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
9954   {
9955     try {
9956       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
9957     } CALL_CATCH_EXCEPTION(0);
9958   }
9959
9960   jresult = (void *)result;
9961
9962   //argout typemap for const std::string&
9963
9964   return jresult;
9965 }
9966
9967
9968 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
9969   char * jresult ;
9970   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
9971   std::string result;
9972
9973   arg1 = (Dali::TypeRegistration *)jarg1;
9974   {
9975     try {
9976       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
9977     } CALL_CATCH_EXCEPTION(0);
9978   }
9979
9980   jresult = SWIG_csharp_string_callback((&result)->c_str());
9981   return jresult;
9982 }
9983
9984
9985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
9986   std::string *arg1 = 0 ;
9987   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
9988
9989   if (!jarg1) {
9990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
9991     return ;
9992   }
9993   std::string arg1_str(jarg1);
9994   arg1 = &arg1_str;
9995   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
9996   {
9997     try {
9998       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
9999     } CALL_CATCH_EXCEPTION();
10000   }
10001
10002
10003   //argout typemap for const std::string&
10004
10005 }
10006
10007
10008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10009   std::string *arg1 = 0 ;
10010   std::string *arg2 = 0 ;
10011   int arg3 ;
10012   Dali::Property::Type arg4 ;
10013   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
10014   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
10015
10016   if (!jarg1) {
10017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10018     return ;
10019   }
10020   std::string arg1_str(jarg1);
10021   arg1 = &arg1_str;
10022   if (!jarg2) {
10023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10024     return ;
10025   }
10026   std::string arg2_str(jarg2);
10027   arg2 = &arg2_str;
10028   arg3 = (int)jarg3;
10029   arg4 = (Dali::Property::Type)jarg4;
10030   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
10031   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
10032   {
10033     try {
10034       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10035     } CALL_CATCH_EXCEPTION();
10036   }
10037
10038
10039   //argout typemap for const std::string&
10040
10041
10042   //argout typemap for const std::string&
10043
10044 }
10045
10046
10047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
10048   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
10049
10050   arg1 = (Dali::TypeRegistration *)jarg1;
10051   {
10052     try {
10053       delete arg1;
10054     } CALL_CATCH_EXCEPTION();
10055   }
10056
10057 }
10058
10059
10060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
10061   void * jresult ;
10062   Dali::TypeRegistration *arg1 = 0 ;
10063   std::string *arg2 = 0 ;
10064   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
10065   Dali::SignalConnectorType *result = 0 ;
10066
10067   arg1 = (Dali::TypeRegistration *)jarg1;
10068   if (!arg1) {
10069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10070     return 0;
10071   }
10072   if (!jarg2) {
10073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10074     return 0;
10075   }
10076   std::string arg2_str(jarg2);
10077   arg2 = &arg2_str;
10078   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
10079   {
10080     try {
10081       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
10082     } CALL_CATCH_EXCEPTION(0);
10083   }
10084
10085   jresult = (void *)result;
10086
10087   //argout typemap for const std::string&
10088
10089   return jresult;
10090 }
10091
10092
10093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
10094   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
10095
10096   arg1 = (Dali::SignalConnectorType *)jarg1;
10097   {
10098     try {
10099       delete arg1;
10100     } CALL_CATCH_EXCEPTION();
10101   }
10102
10103 }
10104
10105
10106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
10107   void * jresult ;
10108   Dali::TypeRegistration *arg1 = 0 ;
10109   std::string *arg2 = 0 ;
10110   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
10111   Dali::TypeAction *result = 0 ;
10112
10113   arg1 = (Dali::TypeRegistration *)jarg1;
10114   if (!arg1) {
10115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10116     return 0;
10117   }
10118   if (!jarg2) {
10119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10120     return 0;
10121   }
10122   std::string arg2_str(jarg2);
10123   arg2 = &arg2_str;
10124   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
10125   {
10126     try {
10127       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
10128     } CALL_CATCH_EXCEPTION(0);
10129   }
10130
10131   jresult = (void *)result;
10132
10133   //argout typemap for const std::string&
10134
10135   return jresult;
10136 }
10137
10138
10139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
10140   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
10141
10142   arg1 = (Dali::TypeAction *)jarg1;
10143   {
10144     try {
10145       delete arg1;
10146     } CALL_CATCH_EXCEPTION();
10147   }
10148
10149 }
10150
10151
10152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10153   void * jresult ;
10154   Dali::TypeRegistration *arg1 = 0 ;
10155   std::string *arg2 = 0 ;
10156   Dali::Property::Index arg3 ;
10157   Dali::Property::Type arg4 ;
10158   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
10159   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
10160   Dali::PropertyRegistration *result = 0 ;
10161
10162   arg1 = (Dali::TypeRegistration *)jarg1;
10163   if (!arg1) {
10164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10165     return 0;
10166   }
10167   if (!jarg2) {
10168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10169     return 0;
10170   }
10171   std::string arg2_str(jarg2);
10172   arg2 = &arg2_str;
10173   arg3 = (Dali::Property::Index)jarg3;
10174   arg4 = (Dali::Property::Type)jarg4;
10175   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
10176   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
10177   {
10178     try {
10179       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10180     } CALL_CATCH_EXCEPTION(0);
10181   }
10182
10183   jresult = (void *)result;
10184
10185   //argout typemap for const std::string&
10186
10187   return jresult;
10188 }
10189
10190
10191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
10192   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
10193
10194   arg1 = (Dali::PropertyRegistration *)jarg1;
10195   {
10196     try {
10197       delete arg1;
10198     } CALL_CATCH_EXCEPTION();
10199   }
10200
10201 }
10202
10203
10204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
10205   void * jresult ;
10206   Dali::TypeRegistration *arg1 = 0 ;
10207   std::string *arg2 = 0 ;
10208   Dali::Property::Index arg3 ;
10209   Dali::Property::Type arg4 ;
10210   Dali::AnimatablePropertyRegistration *result = 0 ;
10211
10212   arg1 = (Dali::TypeRegistration *)jarg1;
10213   if (!arg1) {
10214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10215     return 0;
10216   }
10217   if (!jarg2) {
10218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10219     return 0;
10220   }
10221   std::string arg2_str(jarg2);
10222   arg2 = &arg2_str;
10223   arg3 = (Dali::Property::Index)jarg3;
10224   arg4 = (Dali::Property::Type)jarg4;
10225   {
10226     try {
10227       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
10228     } CALL_CATCH_EXCEPTION(0);
10229   }
10230
10231   jresult = (void *)result;
10232
10233   //argout typemap for const std::string&
10234
10235   return jresult;
10236 }
10237
10238
10239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
10240   void * jresult ;
10241   Dali::TypeRegistration *arg1 = 0 ;
10242   std::string *arg2 = 0 ;
10243   Dali::Property::Index arg3 ;
10244   Dali::Property::Value *arg4 = 0 ;
10245   Dali::AnimatablePropertyRegistration *result = 0 ;
10246
10247   arg1 = (Dali::TypeRegistration *)jarg1;
10248   if (!arg1) {
10249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10250     return 0;
10251   }
10252   if (!jarg2) {
10253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10254     return 0;
10255   }
10256   std::string arg2_str(jarg2);
10257   arg2 = &arg2_str;
10258   arg3 = (Dali::Property::Index)jarg3;
10259   arg4 = (Dali::Property::Value *)jarg4;
10260   if (!arg4) {
10261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
10262     return 0;
10263   }
10264   {
10265     try {
10266       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
10267     } CALL_CATCH_EXCEPTION(0);
10268   }
10269
10270   jresult = (void *)result;
10271
10272   //argout typemap for const std::string&
10273
10274   return jresult;
10275 }
10276
10277
10278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
10279   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
10280
10281   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
10282   {
10283     try {
10284       delete arg1;
10285     } CALL_CATCH_EXCEPTION();
10286   }
10287
10288 }
10289
10290
10291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
10292   void * jresult ;
10293   Dali::TypeRegistration *arg1 = 0 ;
10294   std::string *arg2 = 0 ;
10295   Dali::Property::Index arg3 ;
10296   Dali::Property::Index arg4 ;
10297   unsigned int arg5 ;
10298   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
10299
10300   arg1 = (Dali::TypeRegistration *)jarg1;
10301   if (!arg1) {
10302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10303     return 0;
10304   }
10305   if (!jarg2) {
10306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10307     return 0;
10308   }
10309   std::string arg2_str(jarg2);
10310   arg2 = &arg2_str;
10311   arg3 = (Dali::Property::Index)jarg3;
10312   arg4 = (Dali::Property::Index)jarg4;
10313   arg5 = (unsigned int)jarg5;
10314   {
10315     try {
10316       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
10317     } CALL_CATCH_EXCEPTION(0);
10318   }
10319
10320   jresult = (void *)result;
10321
10322   //argout typemap for const std::string&
10323
10324   return jresult;
10325 }
10326
10327
10328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
10329   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
10330
10331   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
10332   {
10333     try {
10334       delete arg1;
10335     } CALL_CATCH_EXCEPTION();
10336   }
10337
10338 }
10339
10340
10341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
10342   void * jresult ;
10343   Dali::TypeRegistration *arg1 = 0 ;
10344   std::string *arg2 = 0 ;
10345   Dali::Property::Index arg3 ;
10346   Dali::Property::Type arg4 ;
10347   Dali::ChildPropertyRegistration *result = 0 ;
10348
10349   arg1 = (Dali::TypeRegistration *)jarg1;
10350   if (!arg1) {
10351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
10352     return 0;
10353   }
10354   if (!jarg2) {
10355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10356     return 0;
10357   }
10358   std::string arg2_str(jarg2);
10359   arg2 = &arg2_str;
10360   arg3 = (Dali::Property::Index)jarg3;
10361   arg4 = (Dali::Property::Type)jarg4;
10362   {
10363     try {
10364       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
10365     } CALL_CATCH_EXCEPTION(0);
10366   }
10367
10368   jresult = (void *)result;
10369
10370   //argout typemap for const std::string&
10371
10372   return jresult;
10373 }
10374
10375
10376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
10377   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
10378
10379   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
10380   {
10381     try {
10382       delete arg1;
10383     } CALL_CATCH_EXCEPTION();
10384   }
10385
10386 }
10387
10388
10389 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
10390   bool jresult ;
10391   std::string *arg1 = 0 ;
10392   std::type_info *arg2 = 0 ;
10393   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
10394   bool result;
10395
10396   if (!jarg1) {
10397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10398     return 0;
10399   }
10400   std::string arg1_str(jarg1);
10401   arg1 = &arg1_str;
10402   arg2 = (std::type_info *)jarg2;
10403   if (!arg2) {
10404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
10405     return 0;
10406   }
10407   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
10408   {
10409     try {
10410       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
10411     } CALL_CATCH_EXCEPTION(0);
10412   }
10413
10414   jresult = result;
10415
10416   //argout typemap for const std::string&
10417
10418   return jresult;
10419 }
10420
10421
10422 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
10423   bool jresult ;
10424   std::string *arg1 = 0 ;
10425   std::string *arg2 = 0 ;
10426   Dali::Property::Index arg3 ;
10427   Dali::Property::Type arg4 ;
10428   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
10429   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
10430   bool result;
10431
10432   if (!jarg1) {
10433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10434     return 0;
10435   }
10436   std::string arg1_str(jarg1);
10437   arg1 = &arg1_str;
10438   if (!jarg2) {
10439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
10440     return 0;
10441   }
10442   std::string arg2_str(jarg2);
10443   arg2 = &arg2_str;
10444   arg3 = (Dali::Property::Index)jarg3;
10445   arg4 = (Dali::Property::Type)jarg4;
10446   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
10447   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
10448   {
10449     try {
10450       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
10451     } CALL_CATCH_EXCEPTION(0);
10452   }
10453
10454   jresult = result;
10455
10456   //argout typemap for const std::string&
10457
10458
10459   //argout typemap for const std::string&
10460
10461   return jresult;
10462 }
10463
10464
10465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
10466   int jresult ;
10467   Dali::ResizePolicy::Type result;
10468
10469   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
10470   jresult = (int)result;
10471   return jresult;
10472 }
10473
10474
10475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
10476   unsigned long jresult ;
10477   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10478   Dali::VectorBase::SizeType result;
10479
10480   arg1 = (Dali::VectorBase *)jarg1;
10481   {
10482     try {
10483       result = ((Dali::VectorBase const *)arg1)->Count();
10484     } CALL_CATCH_EXCEPTION(0);
10485   }
10486
10487   jresult = (unsigned long)result;
10488   return jresult;
10489 }
10490
10491
10492 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
10493   unsigned long jresult ;
10494   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10495   Dali::VectorBase::SizeType result;
10496
10497   arg1 = (Dali::VectorBase *)jarg1;
10498   {
10499     try {
10500       result = ((Dali::VectorBase const *)arg1)->Size();
10501     } CALL_CATCH_EXCEPTION(0);
10502   }
10503
10504   jresult = (unsigned long)result;
10505   return jresult;
10506 }
10507
10508
10509 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
10510   bool jresult ;
10511   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10512   bool result;
10513
10514   arg1 = (Dali::VectorBase *)jarg1;
10515   {
10516     try {
10517       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
10518     } CALL_CATCH_EXCEPTION(0);
10519   }
10520
10521   jresult = result;
10522   return jresult;
10523 }
10524
10525
10526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
10527   unsigned long jresult ;
10528   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10529   Dali::VectorBase::SizeType result;
10530
10531   arg1 = (Dali::VectorBase *)jarg1;
10532   {
10533     try {
10534       result = ((Dali::VectorBase const *)arg1)->Capacity();
10535     } CALL_CATCH_EXCEPTION(0);
10536   }
10537
10538   jresult = (unsigned long)result;
10539   return jresult;
10540 }
10541
10542
10543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
10544   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
10545
10546   arg1 = (Dali::VectorBase *)jarg1;
10547   {
10548     try {
10549       (arg1)->Release();
10550     } CALL_CATCH_EXCEPTION();
10551   }
10552
10553 }
10554
10555
10556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
10557   int jresult ;
10558   Dali::Pixel::Format result;
10559
10560   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
10561   jresult = (int)result;
10562   return jresult;
10563 }
10564
10565
10566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
10567   int jresult ;
10568   Dali::Pixel::Format result;
10569
10570   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
10571   jresult = (int)result;
10572   return jresult;
10573 }
10574
10575
10576 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
10577   bool jresult ;
10578   Dali::Pixel::Format arg1 ;
10579   bool result;
10580
10581   arg1 = (Dali::Pixel::Format)jarg1;
10582   {
10583     try {
10584       result = (bool)Dali::Pixel::HasAlpha(arg1);
10585     } CALL_CATCH_EXCEPTION(0);
10586   }
10587
10588   jresult = result;
10589   return jresult;
10590 }
10591
10592
10593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
10594   unsigned int jresult ;
10595   Dali::Pixel::Format arg1 ;
10596   unsigned int result;
10597
10598   arg1 = (Dali::Pixel::Format)jarg1;
10599   {
10600     try {
10601       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
10602     } CALL_CATCH_EXCEPTION(0);
10603   }
10604
10605   jresult = result;
10606   return jresult;
10607 }
10608
10609
10610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
10611   Dali::Pixel::Format arg1 ;
10612   int *arg2 = 0 ;
10613   int *arg3 = 0 ;
10614
10615   arg1 = (Dali::Pixel::Format)jarg1;
10616   arg2 = (int *)jarg2;
10617   if (!arg2) {
10618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
10619     return ;
10620   }
10621   arg3 = (int *)jarg3;
10622   if (!arg3) {
10623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
10624     return ;
10625   }
10626   {
10627     try {
10628       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
10629     } CALL_CATCH_EXCEPTION();
10630   }
10631
10632 }
10633
10634
10635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* nuiBuffer, unsigned int nuiBufferSize, unsigned int nuiWidth, unsigned int nuiHeight, int nuiPixelFormat) {
10636   void * jresult ;
10637   Dali::PixelData result;
10638
10639   {
10640     unsigned char* copiedBuffer;
10641     try
10642     {
10643       copiedBuffer = new unsigned char[nuiBufferSize];
10644     } CALL_CATCH_EXCEPTION(0);
10645
10646     try
10647     {
10648       // Note : copiedBuffer created by 'new' method. So ReleaseFunction always be DELETE_ARRAY.
10649       memcpy(copiedBuffer, nuiBuffer, nuiBufferSize);
10650       result = Dali::PixelData::New(copiedBuffer, nuiBufferSize, nuiWidth, nuiHeight, (Dali::Pixel::Format)nuiPixelFormat, Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
10651     } CALL_CATCH_EXCEPTION_WITH_FUNCTION(0, [](unsigned char* buffer){delete[] buffer;}, copiedBuffer);
10652   }
10653
10654   jresult = new Dali::PixelData((const Dali::PixelData &)result);
10655
10656   return jresult;
10657 }
10658
10659
10660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
10661   void * jresult ;
10662   Dali::PixelData *result = 0 ;
10663
10664   {
10665     try {
10666       result = (Dali::PixelData *)new Dali::PixelData();
10667     } CALL_CATCH_EXCEPTION(0);
10668   }
10669
10670   jresult = (void *)result;
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * nuiHandle) {
10676   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
10677
10678   pixelData = (Dali::PixelData *)nuiHandle;
10679   {
10680     try {
10681       delete pixelData;
10682     } CALL_CATCH_EXCEPTION();
10683   }
10684
10685 }
10686
10687
10688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * nuiHandle) {
10689   void * jresult ;
10690   Dali::PixelData *pixelData = 0 ;
10691   Dali::PixelData *result = 0 ;
10692
10693   pixelData = (Dali::PixelData *)nuiHandle;
10694   if (!pixelData) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
10696     return 0;
10697   }
10698   {
10699     try {
10700       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*pixelData);
10701     } CALL_CATCH_EXCEPTION(0);
10702   }
10703
10704   jresult = (void *)result;
10705   return jresult;
10706 }
10707
10708
10709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * nuiHandle, void * nuiHandleSource) {
10710   void * jresult ;
10711   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
10712   Dali::PixelData *pixelDataSource = 0 ;
10713   Dali::PixelData *result = 0 ;
10714
10715   pixelData = (Dali::PixelData *)nuiHandle;
10716   pixelDataSource = (Dali::PixelData *)nuiHandleSource;
10717   if (!pixelDataSource) {
10718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
10719     return 0;
10720   }
10721   {
10722     try {
10723       result = (Dali::PixelData *) &(pixelData)->operator =((Dali::PixelData const &)*pixelDataSource);
10724     } CALL_CATCH_EXCEPTION(0);
10725   }
10726
10727   jresult = (void *)result;
10728   return jresult;
10729 }
10730
10731
10732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * nuiHandle) {
10733   unsigned int jresult ;
10734   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
10735   unsigned int result;
10736
10737   pixelData = (Dali::PixelData *)nuiHandle;
10738   {
10739     try {
10740       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetWidth();
10741     } CALL_CATCH_EXCEPTION(0);
10742   }
10743
10744   jresult = result;
10745   return jresult;
10746 }
10747
10748
10749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * nuiHandle) {
10750   unsigned int jresult ;
10751   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
10752   unsigned int result;
10753
10754   pixelData = (Dali::PixelData *)nuiHandle;
10755   {
10756     try {
10757       result = (unsigned int)((Dali::PixelData const *)pixelData)->GetHeight();
10758     } CALL_CATCH_EXCEPTION(0);
10759   }
10760
10761   jresult = result;
10762   return jresult;
10763 }
10764
10765
10766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * nuiHandle) {
10767   int jresult ;
10768   Dali::PixelData *pixelData = (Dali::PixelData *) 0 ;
10769   Dali::Pixel::Format result;
10770
10771   pixelData = (Dali::PixelData *)nuiHandle;
10772   {
10773     try {
10774       result = (Dali::Pixel::Format)((Dali::PixelData const *)pixelData)->GetPixelFormat();
10775     } CALL_CATCH_EXCEPTION(0);
10776   }
10777
10778   jresult = (int)result;
10779   return jresult;
10780 }
10781
10782 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_PixelData_GenerateUrl(void* nuiHandle)
10783 {
10784   Dali::PixelData *pixelData = (Dali::PixelData*)nuiHandle;
10785   Dali::Toolkit::ImageUrl result;
10786   void *jresult;
10787
10788   if (!pixelData)
10789   {
10790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
10791     return 0;
10792   }
10793   {
10794     try
10795     {
10796       result = Dali::Toolkit::Image::GenerateUrl(*pixelData);
10797     } CALL_CATCH_EXCEPTION(0);
10798   }
10799
10800   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl&)result);
10801   return jresult;
10802 }
10803
10804
10805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
10806   unsigned int jresult ;
10807   unsigned int result;
10808
10809   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
10810   jresult = result;
10811   return jresult;
10812 }
10813
10814
10815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
10816   unsigned int jresult ;
10817   unsigned int result;
10818
10819   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
10820   jresult = result;
10821   return jresult;
10822 }
10823
10824
10825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
10826   unsigned int jresult ;
10827   unsigned int result;
10828
10829   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
10830   jresult = result;
10831   return jresult;
10832 }
10833
10834
10835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
10836   unsigned int jresult ;
10837   unsigned int result;
10838
10839   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
10840   jresult = result;
10841   return jresult;
10842 }
10843
10844
10845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
10846   unsigned int jresult ;
10847   unsigned int result;
10848
10849   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
10850   jresult = result;
10851   return jresult;
10852 }
10853
10854
10855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
10856   unsigned int jresult ;
10857   unsigned int result;
10858
10859   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
10860   jresult = result;
10861   return jresult;
10862 }
10863
10864
10865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
10866   void * jresult ;
10867   Dali::TextureType::Type arg1 ;
10868   Dali::Pixel::Format arg2 ;
10869   unsigned int arg3 ;
10870   unsigned int arg4 ;
10871   Dali::Texture result;
10872
10873   arg1 = (Dali::TextureType::Type)jarg1;
10874   arg2 = (Dali::Pixel::Format)jarg2;
10875   arg3 = (unsigned int)jarg3;
10876   arg4 = (unsigned int)jarg4;
10877   {
10878     try {
10879       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
10880     } CALL_CATCH_EXCEPTION(0);
10881   }
10882
10883   jresult = new Dali::Texture((const Dali::Texture &)result);
10884   return jresult;
10885 }
10886
10887
10888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
10889   void * jresult ;
10890   NativeImageInterface *arg1 = 0 ;
10891   Dali::Texture result;
10892
10893   arg1 = (NativeImageInterface *)jarg1;
10894   if (!arg1) {
10895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
10896     return 0;
10897   }
10898   {
10899     try {
10900       result = Dali::Texture::New(*arg1);
10901     } CALL_CATCH_EXCEPTION(0);
10902   }
10903
10904   jresult = new Dali::Texture((const Dali::Texture &)result);
10905   return jresult;
10906 }
10907
10908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
10909   void * jresult ;
10910   Dali::Texture *result = 0 ;
10911
10912   {
10913     try {
10914       result = (Dali::Texture *)new Dali::Texture();
10915     } CALL_CATCH_EXCEPTION(0);
10916   }
10917
10918   jresult = (void *)result;
10919   return jresult;
10920 }
10921
10922
10923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
10924   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
10925
10926   arg1 = (Dali::Texture *)jarg1;
10927   {
10928     try {
10929       delete arg1;
10930     } CALL_CATCH_EXCEPTION();
10931   }
10932
10933 }
10934
10935
10936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
10937   void * jresult ;
10938   Dali::Texture *arg1 = 0 ;
10939   Dali::Texture *result = 0 ;
10940
10941   arg1 = (Dali::Texture *)jarg1;
10942   if (!arg1) {
10943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
10944     return 0;
10945   }
10946   {
10947     try {
10948       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
10949     } CALL_CATCH_EXCEPTION(0);
10950   }
10951
10952   jresult = (void *)result;
10953   return jresult;
10954 }
10955
10956
10957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
10958   void * jresult ;
10959   Dali::BaseHandle arg1 ;
10960   Dali::BaseHandle *argp1 ;
10961   Dali::Texture result;
10962
10963   argp1 = (Dali::BaseHandle *)jarg1;
10964   if (!argp1) {
10965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
10966     return 0;
10967   }
10968   arg1 = *argp1;
10969   {
10970     try {
10971       result = Dali::Texture::DownCast(arg1);
10972     } CALL_CATCH_EXCEPTION(0);
10973   }
10974
10975   jresult = new Dali::Texture((const Dali::Texture &)result);
10976   return jresult;
10977 }
10978
10979
10980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
10981   void * jresult ;
10982   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
10983   Dali::Texture *arg2 = 0 ;
10984   Dali::Texture *result = 0 ;
10985
10986   arg1 = (Dali::Texture *)jarg1;
10987   arg2 = (Dali::Texture *)jarg2;
10988   if (!arg2) {
10989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
10990     return 0;
10991   }
10992   {
10993     try {
10994       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
10995     } CALL_CATCH_EXCEPTION(0);
10996   }
10997
10998   jresult = (void *)result;
10999   return jresult;
11000 }
11001
11002
11003 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
11004   bool jresult ;
11005   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11006   Dali::PixelData arg2 ;
11007   Dali::PixelData *argp2 ;
11008   bool result;
11009
11010   arg1 = (Dali::Texture *)jarg1;
11011   argp2 = (Dali::PixelData *)jarg2;
11012   if (!argp2) {
11013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
11014     return 0;
11015   }
11016   arg2 = *argp2;
11017   {
11018     try {
11019       result = (bool)(arg1)->Upload(arg2);
11020     } CALL_CATCH_EXCEPTION(0);
11021   }
11022
11023   jresult = result;
11024   return jresult;
11025 }
11026
11027
11028 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) {
11029   bool jresult ;
11030   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11031   Dali::PixelData arg2 ;
11032   unsigned int arg3 ;
11033   unsigned int arg4 ;
11034   unsigned int arg5 ;
11035   unsigned int arg6 ;
11036   unsigned int arg7 ;
11037   unsigned int arg8 ;
11038   Dali::PixelData *argp2 ;
11039   bool result;
11040
11041   arg1 = (Dali::Texture *)jarg1;
11042   argp2 = (Dali::PixelData *)jarg2;
11043   if (!argp2) {
11044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
11045     return 0;
11046   }
11047   arg2 = *argp2;
11048   arg3 = (unsigned int)jarg3;
11049   arg4 = (unsigned int)jarg4;
11050   arg5 = (unsigned int)jarg5;
11051   arg6 = (unsigned int)jarg6;
11052   arg7 = (unsigned int)jarg7;
11053   arg8 = (unsigned int)jarg8;
11054   {
11055     try {
11056       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
11057     } CALL_CATCH_EXCEPTION(0);
11058   }
11059
11060   jresult = result;
11061   return jresult;
11062 }
11063
11064
11065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
11066   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11067
11068   arg1 = (Dali::Texture *)jarg1;
11069   {
11070     try {
11071       (arg1)->GenerateMipmaps();
11072     } CALL_CATCH_EXCEPTION();
11073   }
11074
11075 }
11076
11077
11078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
11079   unsigned int jresult ;
11080   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11081   unsigned int result;
11082
11083   arg1 = (Dali::Texture *)jarg1;
11084   {
11085     try {
11086       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
11087     } CALL_CATCH_EXCEPTION(0);
11088   }
11089
11090   jresult = result;
11091   return jresult;
11092 }
11093
11094
11095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
11096   unsigned int jresult ;
11097   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
11098   unsigned int result;
11099
11100   arg1 = (Dali::Texture *)jarg1;
11101   {
11102     try {
11103       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
11104     } CALL_CATCH_EXCEPTION(0);
11105   }
11106
11107   jresult = result;
11108   return jresult;
11109 }
11110
11111
11112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
11113   void * jresult ;
11114   Dali::Sampler result;
11115
11116   {
11117     try {
11118       result = Dali::Sampler::New();
11119     } CALL_CATCH_EXCEPTION(0);
11120   }
11121
11122   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11123   return jresult;
11124 }
11125
11126
11127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
11128   void * jresult ;
11129   Dali::Sampler *result = 0 ;
11130
11131   {
11132     try {
11133       result = (Dali::Sampler *)new Dali::Sampler();
11134     } CALL_CATCH_EXCEPTION(0);
11135   }
11136
11137   jresult = (void *)result;
11138   return jresult;
11139 }
11140
11141
11142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
11143   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11144
11145   arg1 = (Dali::Sampler *)jarg1;
11146   {
11147     try {
11148       delete arg1;
11149     } CALL_CATCH_EXCEPTION();
11150   }
11151
11152 }
11153
11154
11155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
11156   void * jresult ;
11157   Dali::Sampler *arg1 = 0 ;
11158   Dali::Sampler *result = 0 ;
11159
11160   arg1 = (Dali::Sampler *)jarg1;
11161   if (!arg1) {
11162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
11163     return 0;
11164   }
11165   {
11166     try {
11167       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
11168     } CALL_CATCH_EXCEPTION(0);
11169   }
11170
11171   jresult = (void *)result;
11172   return jresult;
11173 }
11174
11175
11176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
11177   void * jresult ;
11178   Dali::BaseHandle arg1 ;
11179   Dali::BaseHandle *argp1 ;
11180   Dali::Sampler result;
11181
11182   argp1 = (Dali::BaseHandle *)jarg1;
11183   if (!argp1) {
11184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11185     return 0;
11186   }
11187   arg1 = *argp1;
11188   {
11189     try {
11190       result = Dali::Sampler::DownCast(arg1);
11191     } CALL_CATCH_EXCEPTION(0);
11192   }
11193
11194   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11195   return jresult;
11196 }
11197
11198
11199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
11200   void * jresult ;
11201   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11202   Dali::Sampler *arg2 = 0 ;
11203   Dali::Sampler *result = 0 ;
11204
11205   arg1 = (Dali::Sampler *)jarg1;
11206   arg2 = (Dali::Sampler *)jarg2;
11207   if (!arg2) {
11208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
11209     return 0;
11210   }
11211   {
11212     try {
11213       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
11214     } CALL_CATCH_EXCEPTION(0);
11215   }
11216
11217   jresult = (void *)result;
11218   return jresult;
11219 }
11220
11221
11222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
11223   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11224   Dali::FilterMode::Type arg2 ;
11225   Dali::FilterMode::Type arg3 ;
11226
11227   arg1 = (Dali::Sampler *)jarg1;
11228   arg2 = (Dali::FilterMode::Type)jarg2;
11229   arg3 = (Dali::FilterMode::Type)jarg3;
11230   {
11231     try {
11232       (arg1)->SetFilterMode(arg2,arg3);
11233     } CALL_CATCH_EXCEPTION();
11234   }
11235
11236 }
11237
11238
11239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
11240   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11241   Dali::WrapMode::Type arg2 ;
11242   Dali::WrapMode::Type arg3 ;
11243
11244   arg1 = (Dali::Sampler *)jarg1;
11245   arg2 = (Dali::WrapMode::Type)jarg2;
11246   arg3 = (Dali::WrapMode::Type)jarg3;
11247   {
11248     try {
11249       (arg1)->SetWrapMode(arg2,arg3);
11250     } CALL_CATCH_EXCEPTION();
11251   }
11252
11253 }
11254
11255
11256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
11257   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
11258   Dali::WrapMode::Type arg2 ;
11259   Dali::WrapMode::Type arg3 ;
11260   Dali::WrapMode::Type arg4 ;
11261
11262   arg1 = (Dali::Sampler *)jarg1;
11263   arg2 = (Dali::WrapMode::Type)jarg2;
11264   arg3 = (Dali::WrapMode::Type)jarg3;
11265   arg4 = (Dali::WrapMode::Type)jarg4;
11266   {
11267     try {
11268       (arg1)->SetWrapMode(arg2,arg3,arg4);
11269     } CALL_CATCH_EXCEPTION();
11270   }
11271
11272 }
11273
11274
11275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
11276   void * jresult ;
11277   Dali::TextureSet result;
11278
11279   {
11280     try {
11281       result = Dali::TextureSet::New();
11282     } CALL_CATCH_EXCEPTION(0);
11283   }
11284
11285   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
11286   return jresult;
11287 }
11288
11289
11290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
11291   void * jresult ;
11292   Dali::TextureSet *result = 0 ;
11293
11294   {
11295     try {
11296       result = (Dali::TextureSet *)new Dali::TextureSet();
11297     } CALL_CATCH_EXCEPTION(0);
11298   }
11299
11300   jresult = (void *)result;
11301   return jresult;
11302 }
11303
11304
11305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
11306   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11307
11308   arg1 = (Dali::TextureSet *)jarg1;
11309   {
11310     try {
11311       delete arg1;
11312     } CALL_CATCH_EXCEPTION();
11313   }
11314
11315 }
11316
11317
11318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
11319   void * jresult ;
11320   Dali::TextureSet *arg1 = 0 ;
11321   Dali::TextureSet *result = 0 ;
11322
11323   arg1 = (Dali::TextureSet *)jarg1;
11324   if (!arg1) {
11325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
11326     return 0;
11327   }
11328   {
11329     try {
11330       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
11331     } CALL_CATCH_EXCEPTION(0);
11332   }
11333
11334   jresult = (void *)result;
11335   return jresult;
11336 }
11337
11338
11339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
11340   void * jresult ;
11341   Dali::BaseHandle arg1 ;
11342   Dali::BaseHandle *argp1 ;
11343   Dali::TextureSet result;
11344
11345   argp1 = (Dali::BaseHandle *)jarg1;
11346   if (!argp1) {
11347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11348     return 0;
11349   }
11350   arg1 = *argp1;
11351   {
11352     try {
11353       result = Dali::TextureSet::DownCast(arg1);
11354     } CALL_CATCH_EXCEPTION(0);
11355   }
11356
11357   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
11358   return jresult;
11359 }
11360
11361
11362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
11363   void * jresult ;
11364   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11365   Dali::TextureSet *arg2 = 0 ;
11366   Dali::TextureSet *result = 0 ;
11367
11368   arg1 = (Dali::TextureSet *)jarg1;
11369   arg2 = (Dali::TextureSet *)jarg2;
11370   if (!arg2) {
11371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
11372     return 0;
11373   }
11374   {
11375     try {
11376       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
11377     } CALL_CATCH_EXCEPTION(0);
11378   }
11379
11380   jresult = (void *)result;
11381   return jresult;
11382 }
11383
11384
11385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
11386   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11387   size_t arg2 ;
11388   Dali::Texture arg3 ;
11389   Dali::Texture *argp3 ;
11390
11391   arg1 = (Dali::TextureSet *)jarg1;
11392   arg2 = (size_t)jarg2;
11393   argp3 = (Dali::Texture *)jarg3;
11394   if (!argp3) {
11395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
11396     return ;
11397   }
11398   arg3 = *argp3;
11399   {
11400     try {
11401       (arg1)->SetTexture(arg2,arg3);
11402     } CALL_CATCH_EXCEPTION();
11403   }
11404
11405 }
11406
11407
11408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
11409   void * jresult ;
11410   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11411   size_t arg2 ;
11412   Dali::Texture result;
11413
11414   arg1 = (Dali::TextureSet *)jarg1;
11415   arg2 = (size_t)jarg2;
11416   {
11417     try {
11418       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
11419     } CALL_CATCH_EXCEPTION(0);
11420   }
11421
11422   jresult = new Dali::Texture((const Dali::Texture &)result);
11423   return jresult;
11424 }
11425
11426
11427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
11428   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11429   size_t arg2 ;
11430   Dali::Sampler arg3 ;
11431   Dali::Sampler *argp3 ;
11432
11433   arg1 = (Dali::TextureSet *)jarg1;
11434   arg2 = (size_t)jarg2;
11435   argp3 = (Dali::Sampler *)jarg3;
11436   if (!argp3) {
11437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
11438     return ;
11439   }
11440   arg3 = *argp3;
11441   {
11442     try {
11443       (arg1)->SetSampler(arg2,arg3);
11444     } CALL_CATCH_EXCEPTION();
11445   }
11446
11447 }
11448
11449
11450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
11451   void * jresult ;
11452   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11453   size_t arg2 ;
11454   Dali::Sampler result;
11455
11456   arg1 = (Dali::TextureSet *)jarg1;
11457   arg2 = (size_t)jarg2;
11458   {
11459     try {
11460       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
11461     } CALL_CATCH_EXCEPTION(0);
11462   }
11463
11464   jresult = new Dali::Sampler((const Dali::Sampler &)result);
11465   return jresult;
11466 }
11467
11468
11469 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
11470   unsigned long jresult ;
11471   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
11472   size_t result;
11473
11474   arg1 = (Dali::TextureSet *)jarg1;
11475   {
11476     try {
11477       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
11478     } CALL_CATCH_EXCEPTION(0);
11479   }
11480
11481   jresult = (unsigned long)result;
11482   return jresult;
11483 }
11484
11485
11486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_New(void * jarg1) {
11487   void * jresult ;
11488   Dali::Property::Map *arg1 = 0 ;
11489   Dali::VertexBuffer result;
11490
11491   arg1 = (Dali::Property::Map *)jarg1;
11492   if (!arg1) {
11493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
11494     return 0;
11495   }
11496   {
11497     try {
11498       result = Dali::VertexBuffer::New(*arg1);
11499     } CALL_CATCH_EXCEPTION(0);
11500   }
11501
11502   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
11503   return jresult;
11504 }
11505
11506
11507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
11508   void * jresult ;
11509   Dali::VertexBuffer *result = 0 ;
11510
11511   {
11512     try {
11513       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
11514     } CALL_CATCH_EXCEPTION(0);
11515   }
11516
11517   jresult = (void *)result;
11518   return jresult;
11519 }
11520
11521
11522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VertexBuffer(void * jarg1) {
11523   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11524
11525   arg1 = (Dali::VertexBuffer *)jarg1;
11526   {
11527     try {
11528       delete arg1;
11529     } CALL_CATCH_EXCEPTION();
11530   }
11531
11532 }
11533
11534
11535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_1(void * jarg1) {
11536   void * jresult ;
11537   Dali::VertexBuffer *arg1 = 0 ;
11538   Dali::VertexBuffer *result = 0 ;
11539
11540   arg1 = (Dali::VertexBuffer *)jarg1;
11541   if (!arg1) {
11542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
11543     return 0;
11544   }
11545   {
11546     try {
11547       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer const &)*arg1);
11548     } CALL_CATCH_EXCEPTION(0);
11549   }
11550
11551   jresult = (void *)result;
11552   return jresult;
11553 }
11554
11555
11556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_DownCast(void * jarg1) {
11557   void * jresult ;
11558   Dali::BaseHandle arg1 ;
11559   Dali::BaseHandle *argp1 ;
11560   Dali::VertexBuffer result;
11561
11562   argp1 = (Dali::BaseHandle *)jarg1;
11563   if (!argp1) {
11564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11565     return 0;
11566   }
11567   arg1 = *argp1;
11568   {
11569     try {
11570       result = Dali::VertexBuffer::DownCast(arg1);
11571     } CALL_CATCH_EXCEPTION(0);
11572   }
11573
11574   jresult = new Dali::VertexBuffer((const Dali::VertexBuffer &)result);
11575   return jresult;
11576 }
11577
11578
11579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
11580   void * jresult ;
11581   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11582   Dali::VertexBuffer *arg2 = 0 ;
11583   Dali::VertexBuffer *result = 0 ;
11584
11585   arg1 = (Dali::VertexBuffer *)jarg1;
11586   arg2 = (Dali::VertexBuffer *)jarg2;
11587   if (!arg2) {
11588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
11589     return 0;
11590   }
11591   {
11592     try {
11593       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer const &)*arg2);
11594     } CALL_CATCH_EXCEPTION(0);
11595   }
11596
11597   jresult = (void *)result;
11598   return jresult;
11599 }
11600
11601
11602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
11603   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11604   void *arg2 = (void *) 0 ;
11605   std::size_t arg3 ;
11606
11607   arg1 = (Dali::VertexBuffer *)jarg1;
11608   arg2 = jarg2;
11609   arg3 = (std::size_t)jarg3;
11610   {
11611     try {
11612       (arg1)->SetData((void const *)arg2,arg3);
11613     } CALL_CATCH_EXCEPTION();
11614   }
11615
11616 }
11617
11618
11619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VertexBuffer_GetSize(void * jarg1) {
11620   unsigned long jresult ;
11621   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
11622   std::size_t result;
11623
11624   arg1 = (Dali::VertexBuffer *)jarg1;
11625   {
11626     try {
11627       result = ((Dali::VertexBuffer const *)arg1)->GetSize();
11628     } CALL_CATCH_EXCEPTION(0);
11629   }
11630
11631   jresult = (unsigned long)result;
11632   return jresult;
11633 }
11634
11635
11636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
11637   void * jresult ;
11638   Dali::Geometry result;
11639
11640   {
11641     try {
11642       result = Dali::Geometry::New();
11643     } CALL_CATCH_EXCEPTION(0);
11644   }
11645
11646   jresult = new Dali::Geometry((const Dali::Geometry &)result);
11647   return jresult;
11648 }
11649
11650
11651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
11652   void * jresult ;
11653   Dali::Geometry *result = 0 ;
11654
11655   {
11656     try {
11657       result = (Dali::Geometry *)new Dali::Geometry();
11658     } CALL_CATCH_EXCEPTION(0);
11659   }
11660
11661   jresult = (void *)result;
11662   return jresult;
11663 }
11664
11665
11666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
11667   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11668
11669   arg1 = (Dali::Geometry *)jarg1;
11670   {
11671     try {
11672       delete arg1;
11673     } CALL_CATCH_EXCEPTION();
11674   }
11675
11676 }
11677
11678
11679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
11680   void * jresult ;
11681   Dali::Geometry *arg1 = 0 ;
11682   Dali::Geometry *result = 0 ;
11683
11684   arg1 = (Dali::Geometry *)jarg1;
11685   if (!arg1) {
11686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
11687     return 0;
11688   }
11689   {
11690     try {
11691       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
11692     } CALL_CATCH_EXCEPTION(0);
11693   }
11694
11695   jresult = (void *)result;
11696   return jresult;
11697 }
11698
11699
11700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
11701   void * jresult ;
11702   Dali::BaseHandle arg1 ;
11703   Dali::BaseHandle *argp1 ;
11704   Dali::Geometry result;
11705
11706   argp1 = (Dali::BaseHandle *)jarg1;
11707   if (!argp1) {
11708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
11709     return 0;
11710   }
11711   arg1 = *argp1;
11712   {
11713     try {
11714       result = Dali::Geometry::DownCast(arg1);
11715     } CALL_CATCH_EXCEPTION(0);
11716   }
11717
11718   jresult = new Dali::Geometry((const Dali::Geometry &)result);
11719   return jresult;
11720 }
11721
11722
11723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
11724   void * jresult ;
11725   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11726   Dali::Geometry *arg2 = 0 ;
11727   Dali::Geometry *result = 0 ;
11728
11729   arg1 = (Dali::Geometry *)jarg1;
11730   arg2 = (Dali::Geometry *)jarg2;
11731   if (!arg2) {
11732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
11733     return 0;
11734   }
11735   {
11736     try {
11737       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
11738     } CALL_CATCH_EXCEPTION(0);
11739   }
11740
11741   jresult = (void *)result;
11742   return jresult;
11743 }
11744
11745
11746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
11747   unsigned long jresult ;
11748   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11749   Dali::VertexBuffer *arg2 = 0 ;
11750   std::size_t result;
11751
11752   arg1 = (Dali::Geometry *)jarg1;
11753   arg2 = (Dali::VertexBuffer *)jarg2;
11754   if (!arg2) {
11755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & type is null", 0);
11756     return 0;
11757   }
11758   {
11759     try {
11760       result = (arg1)->AddVertexBuffer(*arg2);
11761     } CALL_CATCH_EXCEPTION(0);
11762   }
11763
11764   jresult = (unsigned long)result;
11765   return jresult;
11766 }
11767
11768
11769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
11770   unsigned long jresult ;
11771   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11772   std::size_t result;
11773
11774   arg1 = (Dali::Geometry *)jarg1;
11775   {
11776     try {
11777       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
11778     } CALL_CATCH_EXCEPTION(0);
11779   }
11780
11781   jresult = (unsigned long)result;
11782   return jresult;
11783 }
11784
11785
11786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
11787   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11788   std::size_t arg2 ;
11789
11790   arg1 = (Dali::Geometry *)jarg1;
11791   arg2 = (std::size_t)jarg2;
11792   {
11793     try {
11794       (arg1)->RemoveVertexBuffer(arg2);
11795     } CALL_CATCH_EXCEPTION();
11796   }
11797
11798 }
11799
11800
11801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
11802   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11803   unsigned short *arg2 = (unsigned short *) 0 ;
11804   size_t arg3 ;
11805
11806   arg1 = (Dali::Geometry *)jarg1;
11807   arg2 = jarg2;
11808   arg3 = (size_t)jarg3;
11809   {
11810     try {
11811       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
11812     } CALL_CATCH_EXCEPTION();
11813   }
11814
11815
11816
11817 }
11818
11819
11820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
11821   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11822   Dali::Geometry::Type arg2 ;
11823
11824   arg1 = (Dali::Geometry *)jarg1;
11825   arg2 = (Dali::Geometry::Type)jarg2;
11826   {
11827     try {
11828       (arg1)->SetType(arg2);
11829     } CALL_CATCH_EXCEPTION();
11830   }
11831
11832 }
11833
11834
11835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
11836   int jresult ;
11837   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
11838   Dali::Geometry::Type result;
11839
11840   arg1 = (Dali::Geometry *)jarg1;
11841   {
11842     try {
11843       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
11844     } CALL_CATCH_EXCEPTION(0);
11845   }
11846
11847   jresult = (int)result;
11848   return jresult;
11849 }
11850
11851
11852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
11853   void * jresult ;
11854   Dali::Shader::Hint *result = 0 ;
11855
11856   {
11857     try {
11858       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
11859     } CALL_CATCH_EXCEPTION(0);
11860   }
11861
11862   jresult = (void *)result;
11863   return jresult;
11864 }
11865
11866
11867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
11868   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
11869
11870   arg1 = (Dali::Shader::Hint *)jarg1;
11871   {
11872     try {
11873       delete arg1;
11874     } CALL_CATCH_EXCEPTION();
11875   }
11876
11877 }
11878
11879
11880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
11881   int jresult ;
11882   int result;
11883
11884   result = (int)Dali::Shader::Property::PROGRAM;
11885   jresult = (int)result;
11886   return jresult;
11887 }
11888
11889
11890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
11891   void * jresult ;
11892   Dali::Shader::Property *result = 0 ;
11893
11894   {
11895     try {
11896       result = (Dali::Shader::Property *)new Dali::Shader::Property();
11897     } CALL_CATCH_EXCEPTION(0);
11898   }
11899
11900   jresult = (void *)result;
11901   return jresult;
11902 }
11903
11904
11905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
11906   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
11907
11908   arg1 = (Dali::Shader::Property *)jarg1;
11909   {
11910     try {
11911       delete arg1;
11912     } CALL_CATCH_EXCEPTION();
11913   }
11914
11915 }
11916
11917
11918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
11919   void * jresult ;
11920   std::string *arg1 = 0 ;
11921   std::string *arg2 = 0 ;
11922   Dali::Shader::Hint::Value arg3 ;
11923   Dali::Shader result;
11924
11925   if (!jarg1) {
11926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11927     return 0;
11928   }
11929   std::string arg1_str(jarg1);
11930   arg1 = &arg1_str;
11931   if (!jarg2) {
11932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11933     return 0;
11934   }
11935   std::string arg2_str(jarg2);
11936   arg2 = &arg2_str;
11937   arg3 = (Dali::Shader::Hint::Value)jarg3;
11938   {
11939     try {
11940       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
11941     } CALL_CATCH_EXCEPTION(0);
11942   }
11943
11944   jresult = new Dali::Shader((const Dali::Shader &)result);
11945
11946   //argout typemap for const std::string&
11947
11948
11949   //argout typemap for const std::string&
11950
11951   return jresult;
11952 }
11953
11954
11955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
11956   void * jresult ;
11957   std::string *arg1 = 0 ;
11958   std::string *arg2 = 0 ;
11959   Dali::Shader result;
11960
11961   if (!jarg1) {
11962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11963     return 0;
11964   }
11965   std::string arg1_str(jarg1);
11966   arg1 = &arg1_str;
11967   if (!jarg2) {
11968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
11969     return 0;
11970   }
11971   std::string arg2_str(jarg2);
11972   arg2 = &arg2_str;
11973   {
11974     try {
11975       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
11976     } CALL_CATCH_EXCEPTION(0);
11977   }
11978
11979   jresult = new Dali::Shader((const Dali::Shader &)result);
11980
11981   //argout typemap for const std::string&
11982
11983
11984   //argout typemap for const std::string&
11985
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
11991   void * jresult ;
11992   Dali::Shader *result = 0 ;
11993
11994   {
11995     try {
11996       result = (Dali::Shader *)new Dali::Shader();
11997     } CALL_CATCH_EXCEPTION(0);
11998   }
11999
12000   jresult = (void *)result;
12001   return jresult;
12002 }
12003
12004
12005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
12006   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
12007
12008   arg1 = (Dali::Shader *)jarg1;
12009   {
12010     try {
12011       delete arg1;
12012     } CALL_CATCH_EXCEPTION();
12013   }
12014
12015 }
12016
12017
12018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
12019   void * jresult ;
12020   Dali::Shader *arg1 = 0 ;
12021   Dali::Shader *result = 0 ;
12022
12023   arg1 = (Dali::Shader *)jarg1;
12024   if (!arg1) {
12025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
12026     return 0;
12027   }
12028   {
12029     try {
12030       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
12031     } CALL_CATCH_EXCEPTION(0);
12032   }
12033
12034   jresult = (void *)result;
12035   return jresult;
12036 }
12037
12038
12039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
12040   void * jresult ;
12041   Dali::BaseHandle arg1 ;
12042   Dali::BaseHandle *argp1 ;
12043   Dali::Shader result;
12044
12045   argp1 = (Dali::BaseHandle *)jarg1;
12046   if (!argp1) {
12047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12048     return 0;
12049   }
12050   arg1 = *argp1;
12051   {
12052     try {
12053       result = Dali::Shader::DownCast(arg1);
12054     } CALL_CATCH_EXCEPTION(0);
12055   }
12056
12057   jresult = new Dali::Shader((const Dali::Shader &)result);
12058   return jresult;
12059 }
12060
12061
12062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
12063   void * jresult ;
12064   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
12065   Dali::Shader *arg2 = 0 ;
12066   Dali::Shader *result = 0 ;
12067
12068   arg1 = (Dali::Shader *)jarg1;
12069   arg2 = (Dali::Shader *)jarg2;
12070   if (!arg2) {
12071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
12072     return 0;
12073   }
12074   {
12075     try {
12076       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
12077     } CALL_CATCH_EXCEPTION(0);
12078   }
12079
12080   jresult = (void *)result;
12081   return jresult;
12082 }
12083
12084
12085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
12086   int jresult ;
12087   int result;
12088
12089   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
12090   jresult = (int)result;
12091   return jresult;
12092 }
12093
12094
12095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
12096   int jresult ;
12097   int result;
12098
12099   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
12100   jresult = (int)result;
12101   return jresult;
12102 }
12103
12104
12105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
12106   int jresult ;
12107   int result;
12108
12109   result = (int)Dali::Renderer::Property::BLEND_MODE;
12110   jresult = (int)result;
12111   return jresult;
12112 }
12113
12114
12115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
12116   int jresult ;
12117   int result;
12118
12119   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
12120   jresult = (int)result;
12121   return jresult;
12122 }
12123
12124
12125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
12126   int jresult ;
12127   int result;
12128
12129   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
12130   jresult = (int)result;
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
12136   int jresult ;
12137   int result;
12138
12139   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
12140   jresult = (int)result;
12141   return jresult;
12142 }
12143
12144
12145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
12146   int jresult ;
12147   int result;
12148
12149   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
12150   jresult = (int)result;
12151   return jresult;
12152 }
12153
12154
12155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
12156   int jresult ;
12157   int result;
12158
12159   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
12160   jresult = (int)result;
12161   return jresult;
12162 }
12163
12164
12165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
12166   int jresult ;
12167   int result;
12168
12169   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
12170   jresult = (int)result;
12171   return jresult;
12172 }
12173
12174
12175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
12176   int jresult ;
12177   int result;
12178
12179   result = (int)Dali::Renderer::Property::BLEND_COLOR;
12180   jresult = (int)result;
12181   return jresult;
12182 }
12183
12184
12185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
12186   int jresult ;
12187   int result;
12188
12189   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
12190   jresult = (int)result;
12191   return jresult;
12192 }
12193
12194
12195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
12196   int jresult ;
12197   int result;
12198
12199   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
12200   jresult = (int)result;
12201   return jresult;
12202 }
12203
12204
12205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
12206   int jresult ;
12207   int result;
12208
12209   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
12210   jresult = (int)result;
12211   return jresult;
12212 }
12213
12214
12215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
12216   int jresult ;
12217   int result;
12218
12219   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
12220   jresult = (int)result;
12221   return jresult;
12222 }
12223
12224
12225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
12226   int jresult ;
12227   int result;
12228
12229   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
12230   jresult = (int)result;
12231   return jresult;
12232 }
12233
12234
12235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
12236   int jresult ;
12237   int result;
12238
12239   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
12240   jresult = (int)result;
12241   return jresult;
12242 }
12243
12244
12245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
12246   int jresult ;
12247   int result;
12248
12249   result = (int)Dali::Renderer::Property::RENDER_MODE;
12250   jresult = (int)result;
12251   return jresult;
12252 }
12253
12254
12255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
12256   int jresult ;
12257   int result;
12258
12259   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
12260   jresult = (int)result;
12261   return jresult;
12262 }
12263
12264
12265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
12266   int jresult ;
12267   int result;
12268
12269   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
12270   jresult = (int)result;
12271   return jresult;
12272 }
12273
12274
12275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
12276   int jresult ;
12277   int result;
12278
12279   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
12280   jresult = (int)result;
12281   return jresult;
12282 }
12283
12284
12285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
12286   int jresult ;
12287   int result;
12288
12289   result = (int)Dali::Renderer::Property::STENCIL_MASK;
12290   jresult = (int)result;
12291   return jresult;
12292 }
12293
12294
12295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
12296   int jresult ;
12297   int result;
12298
12299   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
12300   jresult = (int)result;
12301   return jresult;
12302 }
12303
12304
12305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
12306   int jresult ;
12307   int result;
12308
12309   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
12310   jresult = (int)result;
12311   return jresult;
12312 }
12313
12314
12315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
12316   int jresult ;
12317   int result;
12318
12319   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
12320   jresult = (int)result;
12321   return jresult;
12322 }
12323
12324
12325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
12326   void * jresult ;
12327   Dali::Renderer::Property *result = 0 ;
12328
12329   {
12330     try {
12331       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
12332     } CALL_CATCH_EXCEPTION(0);
12333   }
12334
12335   jresult = (void *)result;
12336   return jresult;
12337 }
12338
12339
12340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
12341   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
12342
12343   arg1 = (Dali::Renderer::Property *)jarg1;
12344   {
12345     try {
12346       delete arg1;
12347     } CALL_CATCH_EXCEPTION();
12348   }
12349
12350 }
12351
12352
12353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
12354   void * jresult ;
12355   Dali::Geometry *arg1 = 0 ;
12356   Dali::Shader *arg2 = 0 ;
12357   Dali::Renderer result;
12358
12359   arg1 = (Dali::Geometry *)jarg1;
12360   if (!arg1) {
12361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
12362     return 0;
12363   }
12364   arg2 = (Dali::Shader *)jarg2;
12365   if (!arg2) {
12366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
12367     return 0;
12368   }
12369   {
12370     try {
12371       result = Dali::Renderer::New(*arg1,*arg2);
12372     } CALL_CATCH_EXCEPTION(0);
12373   }
12374
12375   jresult = new Dali::Renderer((const Dali::Renderer &)result);
12376   return jresult;
12377 }
12378
12379
12380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
12381   void * jresult ;
12382   Dali::Renderer *result = 0 ;
12383
12384   {
12385     try {
12386       result = (Dali::Renderer *)new Dali::Renderer();
12387     } CALL_CATCH_EXCEPTION(0);
12388   }
12389
12390   jresult = (void *)result;
12391   return jresult;
12392 }
12393
12394
12395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
12396   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12397
12398   arg1 = (Dali::Renderer *)jarg1;
12399   {
12400     try {
12401       delete arg1;
12402     } CALL_CATCH_EXCEPTION();
12403   }
12404
12405 }
12406
12407
12408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
12409   void * jresult ;
12410   Dali::Renderer *arg1 = 0 ;
12411   Dali::Renderer *result = 0 ;
12412
12413   arg1 = (Dali::Renderer *)jarg1;
12414   if (!arg1) {
12415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
12416     return 0;
12417   }
12418   {
12419     try {
12420       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
12421     } CALL_CATCH_EXCEPTION(0);
12422   }
12423
12424   jresult = (void *)result;
12425   return jresult;
12426 }
12427
12428
12429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
12430   void * jresult ;
12431   Dali::BaseHandle arg1 ;
12432   Dali::BaseHandle *argp1 ;
12433   Dali::Renderer result;
12434
12435   argp1 = (Dali::BaseHandle *)jarg1;
12436   if (!argp1) {
12437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12438     return 0;
12439   }
12440   arg1 = *argp1;
12441   {
12442     try {
12443       result = Dali::Renderer::DownCast(arg1);
12444     } CALL_CATCH_EXCEPTION(0);
12445   }
12446
12447   jresult = new Dali::Renderer((const Dali::Renderer &)result);
12448   return jresult;
12449 }
12450
12451
12452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
12453   void * jresult ;
12454   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12455   Dali::Renderer *arg2 = 0 ;
12456   Dali::Renderer *result = 0 ;
12457
12458   arg1 = (Dali::Renderer *)jarg1;
12459   arg2 = (Dali::Renderer *)jarg2;
12460   if (!arg2) {
12461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
12462     return 0;
12463   }
12464   {
12465     try {
12466       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
12467     } CALL_CATCH_EXCEPTION(0);
12468   }
12469
12470   jresult = (void *)result;
12471   return jresult;
12472 }
12473
12474
12475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
12476   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12477   Dali::Geometry *arg2 = 0 ;
12478
12479   arg1 = (Dali::Renderer *)jarg1;
12480   arg2 = (Dali::Geometry *)jarg2;
12481   if (!arg2) {
12482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
12483     return ;
12484   }
12485   {
12486     try {
12487       (arg1)->SetGeometry(*arg2);
12488     } CALL_CATCH_EXCEPTION();
12489   }
12490
12491 }
12492
12493
12494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
12495   void * jresult ;
12496   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12497   Dali::Geometry result;
12498
12499   arg1 = (Dali::Renderer *)jarg1;
12500   {
12501     try {
12502       result = ((Dali::Renderer const *)arg1)->GetGeometry();
12503     } CALL_CATCH_EXCEPTION(0);
12504   }
12505
12506   jresult = new Dali::Geometry((const Dali::Geometry &)result);
12507   return jresult;
12508 }
12509
12510
12511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
12512   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12513   int arg2 ;
12514   int arg3 ;
12515
12516   arg1 = (Dali::Renderer *)jarg1;
12517   arg2 = (int)jarg2;
12518   arg3 = (int)jarg3;
12519   {
12520     try {
12521       (arg1)->SetIndexRange(arg2,arg3);
12522     } CALL_CATCH_EXCEPTION();
12523   }
12524
12525 }
12526
12527
12528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
12529   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12530   Dali::TextureSet *arg2 = 0 ;
12531
12532   arg1 = (Dali::Renderer *)jarg1;
12533   arg2 = (Dali::TextureSet *)jarg2;
12534   if (!arg2) {
12535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
12536     return ;
12537   }
12538   {
12539     try {
12540       (arg1)->SetTextures(*arg2);
12541     } CALL_CATCH_EXCEPTION();
12542   }
12543
12544 }
12545
12546
12547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
12548   void * jresult ;
12549   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12550   Dali::TextureSet result;
12551
12552   arg1 = (Dali::Renderer *)jarg1;
12553   {
12554     try {
12555       result = ((Dali::Renderer const *)arg1)->GetTextures();
12556     } CALL_CATCH_EXCEPTION(0);
12557   }
12558
12559   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
12560   return jresult;
12561 }
12562
12563
12564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
12565   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12566   Dali::Shader *arg2 = 0 ;
12567
12568   arg1 = (Dali::Renderer *)jarg1;
12569   arg2 = (Dali::Shader *)jarg2;
12570   if (!arg2) {
12571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
12572     return ;
12573   }
12574   {
12575     try {
12576       (arg1)->SetShader(*arg2);
12577     } CALL_CATCH_EXCEPTION();
12578   }
12579
12580 }
12581
12582
12583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
12584   void * jresult ;
12585   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
12586   Dali::Shader result;
12587
12588   arg1 = (Dali::Renderer *)jarg1;
12589   {
12590     try {
12591       result = ((Dali::Renderer const *)arg1)->GetShader();
12592     } CALL_CATCH_EXCEPTION(0);
12593   }
12594
12595   jresult = new Dali::Shader((const Dali::Shader &)result);
12596   return jresult;
12597 }
12598
12599
12600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
12601   void * jresult ;
12602   Dali::FrameBuffer::Attachment *result = 0 ;
12603
12604   {
12605     try {
12606       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
12607     } CALL_CATCH_EXCEPTION(0);
12608   }
12609
12610   jresult = (void *)result;
12611   return jresult;
12612 }
12613
12614
12615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
12616   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
12617
12618   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
12619   {
12620     try {
12621       delete arg1;
12622     } CALL_CATCH_EXCEPTION();
12623   }
12624
12625 }
12626
12627
12628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
12629   void * jresult ;
12630   unsigned int arg1 ;
12631   unsigned int arg2 ;
12632   unsigned int arg3 ;
12633   Dali::FrameBuffer result;
12634
12635   arg1 = (unsigned int)jarg1;
12636   arg2 = (unsigned int)jarg2;
12637   arg3 = (unsigned int)jarg3;
12638   {
12639     try {
12640       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
12641     } CALL_CATCH_EXCEPTION(0);
12642   }
12643
12644   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
12645   return jresult;
12646 }
12647
12648
12649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
12650   void * jresult ;
12651   Dali::FrameBuffer *result = 0 ;
12652
12653   {
12654     try {
12655       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
12656     } CALL_CATCH_EXCEPTION(0);
12657   }
12658
12659   jresult = (void *)result;
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
12665   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
12666
12667   arg1 = (Dali::FrameBuffer *)jarg1;
12668   {
12669     try {
12670       delete arg1;
12671     } CALL_CATCH_EXCEPTION();
12672   }
12673
12674 }
12675
12676
12677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
12678   void * jresult ;
12679   Dali::FrameBuffer *arg1 = 0 ;
12680   Dali::FrameBuffer *result = 0 ;
12681
12682   arg1 = (Dali::FrameBuffer *)jarg1;
12683   if (!arg1) {
12684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
12685     return 0;
12686   }
12687   {
12688     try {
12689       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
12690     } CALL_CATCH_EXCEPTION(0);
12691   }
12692
12693   jresult = (void *)result;
12694   return jresult;
12695 }
12696
12697
12698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
12699   void * jresult ;
12700   Dali::BaseHandle arg1 ;
12701   Dali::BaseHandle *argp1 ;
12702   Dali::FrameBuffer result;
12703
12704   argp1 = (Dali::BaseHandle *)jarg1;
12705   if (!argp1) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12707     return 0;
12708   }
12709   arg1 = *argp1;
12710   {
12711     try {
12712       result = Dali::FrameBuffer::DownCast(arg1);
12713     } CALL_CATCH_EXCEPTION(0);
12714   }
12715
12716   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
12717   return jresult;
12718 }
12719
12720
12721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
12722   void * jresult ;
12723   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
12724   Dali::FrameBuffer *arg2 = 0 ;
12725   Dali::FrameBuffer *result = 0 ;
12726
12727   arg1 = (Dali::FrameBuffer *)jarg1;
12728   arg2 = (Dali::FrameBuffer *)jarg2;
12729   if (!arg2) {
12730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
12731     return 0;
12732   }
12733   {
12734     try {
12735       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
12736     } CALL_CATCH_EXCEPTION(0);
12737   }
12738
12739   jresult = (void *)result;
12740   return jresult;
12741 }
12742
12743
12744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
12745   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
12746   Dali::Texture *arg2 = 0 ;
12747
12748   arg1 = (Dali::FrameBuffer *)jarg1;
12749   arg2 = (Dali::Texture *)jarg2;
12750   if (!arg2) {
12751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
12752     return ;
12753   }
12754   {
12755     try {
12756       (arg1)->AttachColorTexture(*arg2);
12757     } CALL_CATCH_EXCEPTION();
12758   }
12759
12760 }
12761
12762
12763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
12764   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
12765   Dali::Texture *arg2 = 0 ;
12766   unsigned int arg3 ;
12767   unsigned int arg4 ;
12768
12769   arg1 = (Dali::FrameBuffer *)jarg1;
12770   arg2 = (Dali::Texture *)jarg2;
12771   if (!arg2) {
12772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
12773     return ;
12774   }
12775   arg3 = (unsigned int)jarg3;
12776   arg4 = (unsigned int)jarg4;
12777   {
12778     try {
12779       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
12780     } CALL_CATCH_EXCEPTION();
12781   }
12782
12783 }
12784
12785
12786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
12787   void * jresult ;
12788   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
12789   Dali::Texture result;
12790
12791   arg1 = (Dali::FrameBuffer *)jarg1;
12792   {
12793     try {
12794       result = (arg1)->GetColorTexture();
12795     } CALL_CATCH_EXCEPTION(0);
12796   }
12797
12798   jresult = new Dali::Texture((const Dali::Texture &)result);
12799   return jresult;
12800 }
12801
12802 SWIGEXPORT void *SWIGSTDCALL CSharp_Dali_FrameBuffer_GenerateUrl(void *jFrameBuffer, int pixelFormat, int width, int height)
12803 {
12804   void *jresult;
12805   Dali::Toolkit::ImageUrl result;
12806   Dali::FrameBuffer *frameBuffer = (Dali::FrameBuffer*)jFrameBuffer;;
12807
12808   if (!frameBuffer)
12809   {
12810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer is null", 0);
12811     return 0;
12812   }
12813   {
12814     try
12815     {
12816       result = Dali::Toolkit::Image::GenerateUrl((const Dali::FrameBuffer&)*frameBuffer, (Pixel::Format)pixelFormat, (uint32_t)width, (uint32_t)height);
12817     }
12818     CALL_CATCH_EXCEPTION(0);
12819   }
12820
12821   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
12822   return jresult;
12823 }
12824
12825
12826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
12827   void * jresult ;
12828   Dali::RenderTaskList *result = 0 ;
12829
12830   {
12831     try {
12832       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
12833     } CALL_CATCH_EXCEPTION(0);
12834   }
12835
12836   jresult = (void *)result;
12837   return jresult;
12838 }
12839
12840
12841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
12842   void * jresult ;
12843   Dali::BaseHandle arg1 ;
12844   Dali::BaseHandle *argp1 ;
12845   Dali::RenderTaskList result;
12846
12847   argp1 = (Dali::BaseHandle *)jarg1;
12848   if (!argp1) {
12849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
12850     return 0;
12851   }
12852   arg1 = *argp1;
12853   {
12854     try {
12855       result = Dali::RenderTaskList::DownCast(arg1);
12856     } CALL_CATCH_EXCEPTION(0);
12857   }
12858
12859   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
12860   return jresult;
12861 }
12862
12863
12864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
12865   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
12866
12867   arg1 = (Dali::RenderTaskList *)jarg1;
12868   {
12869     try {
12870       delete arg1;
12871     } CALL_CATCH_EXCEPTION();
12872   }
12873
12874 }
12875
12876
12877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
12878   void * jresult ;
12879   Dali::RenderTaskList *arg1 = 0 ;
12880   Dali::RenderTaskList *result = 0 ;
12881
12882   arg1 = (Dali::RenderTaskList *)jarg1;
12883   if (!arg1) {
12884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
12885     return 0;
12886   }
12887   {
12888     try {
12889       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
12890     } CALL_CATCH_EXCEPTION(0);
12891   }
12892
12893   jresult = (void *)result;
12894   return jresult;
12895 }
12896
12897
12898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
12899   void * jresult ;
12900   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
12901   Dali::RenderTaskList *arg2 = 0 ;
12902   Dali::RenderTaskList *result = 0 ;
12903
12904   arg1 = (Dali::RenderTaskList *)jarg1;
12905   arg2 = (Dali::RenderTaskList *)jarg2;
12906   if (!arg2) {
12907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
12908     return 0;
12909   }
12910   {
12911     try {
12912       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
12913     } CALL_CATCH_EXCEPTION(0);
12914   }
12915
12916   jresult = (void *)result;
12917   return jresult;
12918 }
12919
12920
12921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
12922   void * jresult ;
12923   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
12924   Dali::RenderTask result;
12925
12926   arg1 = (Dali::RenderTaskList *)jarg1;
12927   {
12928     try {
12929       result = (arg1)->CreateTask();
12930     } CALL_CATCH_EXCEPTION(0);
12931   }
12932
12933   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
12934   return jresult;
12935 }
12936
12937
12938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
12939   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
12940   Dali::RenderTask arg2 ;
12941   Dali::RenderTask *argp2 ;
12942
12943   arg1 = (Dali::RenderTaskList *)jarg1;
12944   argp2 = (Dali::RenderTask *)jarg2;
12945   if (!argp2) {
12946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
12947     return ;
12948   }
12949   arg2 = *argp2;
12950   {
12951     try {
12952       (arg1)->RemoveTask(arg2);
12953     } CALL_CATCH_EXCEPTION();
12954   }
12955
12956 }
12957
12958
12959 //// ===============================================end part 1 =================
12960
12961 //// ========================= part 2 ===============================
12962
12963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
12964   unsigned int jresult ;
12965   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
12966   unsigned int result;
12967
12968   arg1 = (Dali::RenderTaskList *)jarg1;
12969   {
12970     try {
12971       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
12972     } CALL_CATCH_EXCEPTION(0);
12973   }
12974
12975   jresult = result;
12976   return jresult;
12977 }
12978
12979
12980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
12981   void * jresult ;
12982   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
12983   unsigned int arg2 ;
12984   Dali::RenderTask result;
12985
12986   arg1 = (Dali::RenderTaskList *)jarg1;
12987   arg2 = (unsigned int)jarg2;
12988   {
12989     try {
12990       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
12991     } CALL_CATCH_EXCEPTION(0);
12992   }
12993
12994   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
12995   return jresult;
12996 }
12997
12998
12999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
13000   int jresult ;
13001   int result;
13002
13003   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
13004   jresult = (int)result;
13005   return jresult;
13006 }
13007
13008
13009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
13010   int jresult ;
13011   int result;
13012
13013   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
13014   jresult = (int)result;
13015   return jresult;
13016 }
13017
13018
13019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
13020   int jresult ;
13021   int result;
13022
13023   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
13024   jresult = (int)result;
13025   return jresult;
13026 }
13027
13028
13029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
13030   int jresult ;
13031   int result;
13032
13033   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
13034   jresult = (int)result;
13035   return jresult;
13036 }
13037
13038
13039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
13040   void * jresult ;
13041   Dali::RenderTask::Property *result = 0 ;
13042
13043   {
13044     try {
13045       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
13046     } CALL_CATCH_EXCEPTION(0);
13047   }
13048
13049   jresult = (void *)result;
13050   return jresult;
13051 }
13052
13053
13054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
13055   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
13056
13057   arg1 = (Dali::RenderTask::Property *)jarg1;
13058   {
13059     try {
13060       delete arg1;
13061     } CALL_CATCH_EXCEPTION();
13062   }
13063
13064 }
13065
13066
13067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
13068   void * jresult ;
13069   bool (*result)(Dali::Vector2 &) = 0 ;
13070
13071   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
13072   jresult = (void *)result;
13073   return jresult;
13074 }
13075
13076
13077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
13078   void * jresult ;
13079   bool (*result)(Dali::Vector2 &) = 0 ;
13080
13081   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
13082   jresult = (void *)result;
13083   return jresult;
13084 }
13085
13086
13087 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
13088   bool jresult ;
13089   bool result;
13090
13091   result = (bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
13092   jresult = result;
13093   return jresult;
13094 }
13095
13096
13097 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
13098   bool jresult ;
13099   bool result;
13100
13101   result = (bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
13102   jresult = result;
13103   return jresult;
13104 }
13105
13106
13107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
13108   void * jresult ;
13109   Dali::Vector4 *result = 0 ;
13110
13111   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
13112   jresult = (void *)result;
13113   return jresult;
13114 }
13115
13116
13117 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
13118   bool jresult ;
13119   bool result;
13120
13121   result = (bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
13122   jresult = result;
13123   return jresult;
13124 }
13125
13126
13127 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
13128   bool jresult ;
13129   bool result;
13130
13131   result = (bool)Dali::RenderTask::DEFAULT_CULL_MODE;
13132   jresult = result;
13133   return jresult;
13134 }
13135
13136
13137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
13138   unsigned int jresult ;
13139   unsigned int result;
13140
13141   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
13142   jresult = result;
13143   return jresult;
13144 }
13145
13146
13147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
13148   void * jresult ;
13149   Dali::RenderTask *result = 0 ;
13150
13151   {
13152     try {
13153       result = (Dali::RenderTask *)new Dali::RenderTask();
13154     } CALL_CATCH_EXCEPTION(0);
13155   }
13156
13157   jresult = (void *)result;
13158   return jresult;
13159 }
13160
13161
13162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
13163   void * jresult ;
13164   Dali::BaseHandle arg1 ;
13165   Dali::BaseHandle *argp1 ;
13166   Dali::RenderTask result;
13167
13168   argp1 = (Dali::BaseHandle *)jarg1;
13169   if (!argp1) {
13170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
13171     return 0;
13172   }
13173   arg1 = *argp1;
13174   {
13175     try {
13176       result = Dali::RenderTask::DownCast(arg1);
13177     } CALL_CATCH_EXCEPTION(0);
13178   }
13179
13180   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
13181   return jresult;
13182 }
13183
13184
13185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
13186   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13187
13188   arg1 = (Dali::RenderTask *)jarg1;
13189   {
13190     try {
13191       delete arg1;
13192     } CALL_CATCH_EXCEPTION();
13193   }
13194
13195 }
13196
13197
13198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
13199   void * jresult ;
13200   Dali::RenderTask *arg1 = 0 ;
13201   Dali::RenderTask *result = 0 ;
13202
13203   arg1 = (Dali::RenderTask *)jarg1;
13204   if (!arg1) {
13205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
13206     return 0;
13207   }
13208   {
13209     try {
13210       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
13211     } CALL_CATCH_EXCEPTION(0);
13212   }
13213
13214   jresult = (void *)result;
13215   return jresult;
13216 }
13217
13218
13219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
13220   void * jresult ;
13221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13222   Dali::RenderTask *arg2 = 0 ;
13223   Dali::RenderTask *result = 0 ;
13224
13225   arg1 = (Dali::RenderTask *)jarg1;
13226   arg2 = (Dali::RenderTask *)jarg2;
13227   if (!arg2) {
13228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
13229     return 0;
13230   }
13231   {
13232     try {
13233       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
13234     } CALL_CATCH_EXCEPTION(0);
13235   }
13236
13237   jresult = (void *)result;
13238   return jresult;
13239 }
13240
13241
13242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
13243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13244   Dali::Actor arg2 ;
13245   Dali::Actor *argp2 ;
13246
13247   arg1 = (Dali::RenderTask *)jarg1;
13248   argp2 = (Dali::Actor *)jarg2;
13249   if (!argp2) {
13250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13251     return ;
13252   }
13253   arg2 = *argp2;
13254   {
13255     try {
13256       (arg1)->SetSourceActor(arg2);
13257     } CALL_CATCH_EXCEPTION();
13258   }
13259
13260 }
13261
13262
13263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
13264   void * jresult ;
13265   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13266   Dali::Actor result;
13267
13268   arg1 = (Dali::RenderTask *)jarg1;
13269   {
13270     try {
13271       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
13272     } CALL_CATCH_EXCEPTION(0);
13273   }
13274
13275   jresult = new Dali::Actor((const Dali::Actor &)result);
13276   return jresult;
13277 }
13278
13279
13280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, bool jarg2) {
13281   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13282   bool arg2 ;
13283
13284   arg1 = (Dali::RenderTask *)jarg1;
13285   arg2 = jarg2 ? true : false;
13286   {
13287     try {
13288       (arg1)->SetExclusive(arg2);
13289     } CALL_CATCH_EXCEPTION();
13290   }
13291
13292 }
13293
13294
13295 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
13296   bool jresult ;
13297   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13298   bool result;
13299
13300   arg1 = (Dali::RenderTask *)jarg1;
13301   {
13302     try {
13303       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
13304     } CALL_CATCH_EXCEPTION(0);
13305   }
13306
13307   jresult = result;
13308   return jresult;
13309 }
13310
13311
13312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, bool jarg2) {
13313   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13314   bool arg2 ;
13315
13316   arg1 = (Dali::RenderTask *)jarg1;
13317   arg2 = jarg2 ? true : false;
13318   {
13319     try {
13320       (arg1)->SetInputEnabled(arg2);
13321     } CALL_CATCH_EXCEPTION();
13322   }
13323
13324 }
13325
13326
13327 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
13328   bool jresult ;
13329   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13330   bool result;
13331
13332   arg1 = (Dali::RenderTask *)jarg1;
13333   {
13334     try {
13335       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
13336     } CALL_CATCH_EXCEPTION(0);
13337   }
13338
13339   jresult = result;
13340   return jresult;
13341 }
13342
13343
13344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
13345   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13346   Dali::CameraActor arg2 ;
13347   Dali::CameraActor *argp2 ;
13348
13349   arg1 = (Dali::RenderTask *)jarg1;
13350   argp2 = (Dali::CameraActor *)jarg2;
13351   if (!argp2) {
13352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
13353     return ;
13354   }
13355   arg2 = *argp2;
13356   {
13357     try {
13358       (arg1)->SetCameraActor(arg2);
13359     } CALL_CATCH_EXCEPTION();
13360   }
13361
13362 }
13363
13364
13365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
13366   void * jresult ;
13367   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13368   Dali::CameraActor result;
13369
13370   arg1 = (Dali::RenderTask *)jarg1;
13371   {
13372     try {
13373       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
13374     } CALL_CATCH_EXCEPTION(0);
13375   }
13376
13377   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
13378   return jresult;
13379 }
13380
13381
13382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
13383   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13384   Dali::FrameBuffer arg2 ;
13385   Dali::FrameBuffer *argp2 ;
13386
13387   arg1 = (Dali::RenderTask *)jarg1;
13388   argp2 = (Dali::FrameBuffer *)jarg2;
13389   if (!argp2) {
13390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
13391     return ;
13392   }
13393   arg2 = *argp2;
13394   {
13395     try {
13396       (arg1)->SetFrameBuffer(arg2);
13397     } CALL_CATCH_EXCEPTION();
13398   }
13399
13400 }
13401
13402
13403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
13404   void * jresult ;
13405   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13406   Dali::FrameBuffer result;
13407
13408   arg1 = (Dali::RenderTask *)jarg1;
13409   {
13410     try {
13411       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
13412     } CALL_CATCH_EXCEPTION(0);
13413   }
13414
13415   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
13416   return jresult;
13417 }
13418
13419
13420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
13421   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13422   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
13423
13424   arg1 = (Dali::RenderTask *)jarg1;
13425   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
13426   {
13427     try {
13428       (arg1)->SetScreenToFrameBufferFunction(arg2);
13429     } CALL_CATCH_EXCEPTION();
13430   }
13431
13432 }
13433
13434
13435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
13436   void * jresult ;
13437   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13438   Dali::RenderTask::ScreenToFrameBufferFunction result;
13439
13440   arg1 = (Dali::RenderTask *)jarg1;
13441   {
13442     try {
13443       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
13444     } CALL_CATCH_EXCEPTION(0);
13445   }
13446
13447   jresult = (void *)result;
13448   return jresult;
13449 }
13450
13451
13452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
13453   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13454   Dali::Actor arg2 ;
13455   Dali::Actor *argp2 ;
13456
13457   arg1 = (Dali::RenderTask *)jarg1;
13458   argp2 = (Dali::Actor *)jarg2;
13459   if (!argp2) {
13460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13461     return ;
13462   }
13463   arg2 = *argp2;
13464   {
13465     try {
13466       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
13467     } CALL_CATCH_EXCEPTION();
13468   }
13469
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
13474   void * jresult ;
13475   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13476   Dali::Actor result;
13477
13478   arg1 = (Dali::RenderTask *)jarg1;
13479   {
13480     try {
13481       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
13482     } CALL_CATCH_EXCEPTION(0);
13483   }
13484
13485   jresult = new Dali::Actor((const Dali::Actor &)result);
13486   return jresult;
13487 }
13488
13489
13490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
13491   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13492   Dali::Vector2 arg2 ;
13493   Dali::Vector2 *argp2 ;
13494
13495   arg1 = (Dali::RenderTask *)jarg1;
13496   argp2 = (Dali::Vector2 *)jarg2;
13497   if (!argp2) {
13498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
13499     return ;
13500   }
13501   arg2 = *argp2;
13502   {
13503     try {
13504       (arg1)->SetViewportPosition(arg2);
13505     } CALL_CATCH_EXCEPTION();
13506   }
13507
13508 }
13509
13510
13511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
13512   void * jresult ;
13513   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13514   Dali::Vector2 result;
13515
13516   arg1 = (Dali::RenderTask *)jarg1;
13517   {
13518     try {
13519       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
13520     } CALL_CATCH_EXCEPTION(0);
13521   }
13522
13523   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
13524   return jresult;
13525 }
13526
13527
13528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
13529   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13530   Dali::Vector2 arg2 ;
13531   Dali::Vector2 *argp2 ;
13532
13533   arg1 = (Dali::RenderTask *)jarg1;
13534   argp2 = (Dali::Vector2 *)jarg2;
13535   if (!argp2) {
13536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
13537     return ;
13538   }
13539   arg2 = *argp2;
13540   {
13541     try {
13542       (arg1)->SetViewportSize(arg2);
13543     } CALL_CATCH_EXCEPTION();
13544   }
13545
13546 }
13547
13548
13549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
13550   void * jresult ;
13551   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13552   Dali::Vector2 result;
13553
13554   arg1 = (Dali::RenderTask *)jarg1;
13555   {
13556     try {
13557       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
13558     } CALL_CATCH_EXCEPTION(0);
13559   }
13560
13561   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
13562   return jresult;
13563 }
13564
13565
13566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
13567   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13568   Dali::Viewport arg2 ;
13569   Dali::Viewport *argp2 ;
13570
13571   arg1 = (Dali::RenderTask *)jarg1;
13572   argp2 = (Dali::Viewport *)jarg2;
13573   if (!argp2) {
13574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
13575     return ;
13576   }
13577   arg2 = *argp2;
13578   {
13579     try {
13580       (arg1)->SetViewport(arg2);
13581     } CALL_CATCH_EXCEPTION();
13582   }
13583
13584 }
13585
13586
13587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
13588   void * jresult ;
13589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13590   Dali::Viewport result;
13591
13592   arg1 = (Dali::RenderTask *)jarg1;
13593   {
13594     try {
13595       result = ((Dali::RenderTask const *)arg1)->GetViewport();
13596     } CALL_CATCH_EXCEPTION(0);
13597   }
13598
13599   jresult = new Dali::Viewport((const Dali::Viewport &)result);
13600   return jresult;
13601 }
13602
13603
13604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
13605   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13606   Dali::Vector4 *arg2 = 0 ;
13607
13608   arg1 = (Dali::RenderTask *)jarg1;
13609   arg2 = (Dali::Vector4 *)jarg2;
13610   if (!arg2) {
13611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13612     return ;
13613   }
13614   {
13615     try {
13616       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
13617     } CALL_CATCH_EXCEPTION();
13618   }
13619
13620 }
13621
13622
13623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
13624   void * jresult ;
13625   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13626   Dali::Vector4 result;
13627
13628   arg1 = (Dali::RenderTask *)jarg1;
13629   {
13630     try {
13631       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
13632     } CALL_CATCH_EXCEPTION(0);
13633   }
13634
13635   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13636   return jresult;
13637 }
13638
13639
13640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, bool jarg2) {
13641   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13642   bool arg2 ;
13643
13644   arg1 = (Dali::RenderTask *)jarg1;
13645   arg2 = jarg2 ? true : false;
13646   {
13647     try {
13648       (arg1)->SetClearEnabled(arg2);
13649     } CALL_CATCH_EXCEPTION();
13650   }
13651
13652 }
13653
13654
13655 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
13656   bool jresult ;
13657   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13658   bool result;
13659
13660   arg1 = (Dali::RenderTask *)jarg1;
13661   {
13662     try {
13663       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
13664     } CALL_CATCH_EXCEPTION(0);
13665   }
13666
13667   jresult = result;
13668   return jresult;
13669 }
13670
13671
13672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, bool jarg2) {
13673   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13674   bool arg2 ;
13675
13676   arg1 = (Dali::RenderTask *)jarg1;
13677   arg2 = jarg2 ? true : false;
13678   {
13679     try {
13680       (arg1)->SetCullMode(arg2);
13681     } CALL_CATCH_EXCEPTION();
13682   }
13683
13684 }
13685
13686
13687 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
13688   bool jresult ;
13689   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13690   bool result;
13691
13692   arg1 = (Dali::RenderTask *)jarg1;
13693   {
13694     try {
13695       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
13696     } CALL_CATCH_EXCEPTION(0);
13697   }
13698
13699   jresult = result;
13700   return jresult;
13701 }
13702
13703
13704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
13705   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13706   unsigned int arg2 ;
13707
13708   arg1 = (Dali::RenderTask *)jarg1;
13709   arg2 = (unsigned int)jarg2;
13710   {
13711     try {
13712       (arg1)->SetRefreshRate(arg2);
13713     } CALL_CATCH_EXCEPTION();
13714   }
13715
13716 }
13717
13718
13719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
13720   unsigned int jresult ;
13721   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13722   unsigned int result;
13723
13724   arg1 = (Dali::RenderTask *)jarg1;
13725   {
13726     try {
13727       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
13728     } CALL_CATCH_EXCEPTION(0);
13729   }
13730
13731   jresult = result;
13732   return jresult;
13733 }
13734
13735
13736 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
13737   bool jresult ;
13738   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13739   Dali::Vector3 *arg2 = 0 ;
13740   float *arg3 = 0 ;
13741   float *arg4 = 0 ;
13742   bool result;
13743
13744   arg1 = (Dali::RenderTask *)jarg1;
13745   arg2 = (Dali::Vector3 *)jarg2;
13746   if (!arg2) {
13747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13748     return 0;
13749   }
13750   arg3 = (float *)jarg3;
13751   arg4 = (float *)jarg4;
13752   {
13753     try {
13754       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
13755     } CALL_CATCH_EXCEPTION(0);
13756   }
13757
13758   jresult = result;
13759   return jresult;
13760 }
13761
13762
13763 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
13764   bool jresult ;
13765   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13766   Dali::Actor arg2 ;
13767   float arg3 ;
13768   float arg4 ;
13769   float *arg5 = 0 ;
13770   float *arg6 = 0 ;
13771   Dali::Actor *argp2 ;
13772   bool result;
13773
13774   arg1 = (Dali::RenderTask *)jarg1;
13775   argp2 = (Dali::Actor *)jarg2;
13776   if (!argp2) {
13777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
13778     return 0;
13779   }
13780   arg2 = *argp2;
13781   arg3 = (float)jarg3;
13782   arg4 = (float)jarg4;
13783   arg5 = (float *)jarg5;
13784   arg6 = (float *)jarg6;
13785   {
13786     try {
13787       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
13788     } CALL_CATCH_EXCEPTION(0);
13789   }
13790
13791   jresult = result;
13792   return jresult;
13793 }
13794
13795
13796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
13797   void * jresult ;
13798   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
13799   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
13800
13801   arg1 = (Dali::RenderTask *)jarg1;
13802   {
13803     try {
13804       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
13805     } CALL_CATCH_EXCEPTION(0);
13806   }
13807
13808   jresult = (void *)result;
13809   return jresult;
13810 }
13811
13812
13813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
13814   void * jresult ;
13815   int arg1 ;
13816   Dali::PointState::Type arg2 ;
13817   float arg3 ;
13818   float arg4 ;
13819   Dali::TouchPoint *result = 0 ;
13820
13821   arg1 = (int)jarg1;
13822   arg2 = (Dali::PointState::Type)jarg2;
13823   arg3 = (float)jarg3;
13824   arg4 = (float)jarg4;
13825   {
13826     try {
13827       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
13828     } CALL_CATCH_EXCEPTION(0);
13829   }
13830
13831   jresult = (void *)result;
13832   return jresult;
13833 }
13834
13835
13836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
13837   void * jresult ;
13838   int arg1 ;
13839   Dali::PointState::Type arg2 ;
13840   float arg3 ;
13841   float arg4 ;
13842   float arg5 ;
13843   float arg6 ;
13844   Dali::TouchPoint *result = 0 ;
13845
13846   arg1 = (int)jarg1;
13847   arg2 = (Dali::PointState::Type)jarg2;
13848   arg3 = (float)jarg3;
13849   arg4 = (float)jarg4;
13850   arg5 = (float)jarg5;
13851   arg6 = (float)jarg6;
13852   {
13853     try {
13854       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
13855     } CALL_CATCH_EXCEPTION(0);
13856   }
13857
13858   jresult = (void *)result;
13859   return jresult;
13860 }
13861
13862
13863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
13864   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13865
13866   arg1 = (Dali::TouchPoint *)jarg1;
13867   {
13868     try {
13869       delete arg1;
13870     } CALL_CATCH_EXCEPTION();
13871   }
13872
13873 }
13874
13875
13876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
13877   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13878   int arg2 ;
13879
13880   arg1 = (Dali::TouchPoint *)jarg1;
13881   arg2 = (int)jarg2;
13882   if (arg1) (arg1)->deviceId = arg2;
13883 }
13884
13885
13886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
13887   int jresult ;
13888   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13889   int result;
13890
13891   arg1 = (Dali::TouchPoint *)jarg1;
13892   result = (int) ((arg1)->deviceId);
13893   jresult = result;
13894   return jresult;
13895 }
13896
13897
13898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
13899   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13900   Dali::PointState::Type arg2 ;
13901
13902   arg1 = (Dali::TouchPoint *)jarg1;
13903   arg2 = (Dali::PointState::Type)jarg2;
13904   if (arg1) (arg1)->state = arg2;
13905 }
13906
13907
13908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
13909   int jresult ;
13910   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13911   Dali::PointState::Type result;
13912
13913   arg1 = (Dali::TouchPoint *)jarg1;
13914   result = (Dali::PointState::Type) ((arg1)->state);
13915   jresult = (int)result;
13916   return jresult;
13917 }
13918
13919
13920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
13921   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13922   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
13923
13924   arg1 = (Dali::TouchPoint *)jarg1;
13925   arg2 = (Dali::Actor *)jarg2;
13926   if (arg1) (arg1)->hitActor = *arg2;
13927 }
13928
13929
13930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
13931   void * jresult ;
13932   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13933   Dali::Actor *result = 0 ;
13934
13935   arg1 = (Dali::TouchPoint *)jarg1;
13936   result = (Dali::Actor *)& ((arg1)->hitActor);
13937   jresult = (void *)result;
13938   return jresult;
13939 }
13940
13941
13942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
13943   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13944   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
13945
13946   arg1 = (Dali::TouchPoint *)jarg1;
13947   arg2 = (Dali::Vector2 *)jarg2;
13948   if (arg1) (arg1)->local = *arg2;
13949 }
13950
13951
13952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
13953   void * jresult ;
13954   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13955   Dali::Vector2 *result = 0 ;
13956
13957   arg1 = (Dali::TouchPoint *)jarg1;
13958   result = (Dali::Vector2 *)& ((arg1)->local);
13959   jresult = (void *)result;
13960   return jresult;
13961 }
13962
13963
13964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
13965   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13966   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
13967
13968   arg1 = (Dali::TouchPoint *)jarg1;
13969   arg2 = (Dali::Vector2 *)jarg2;
13970   if (arg1) (arg1)->screen = *arg2;
13971 }
13972
13973
13974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
13975   void * jresult ;
13976   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
13977   Dali::Vector2 *result = 0 ;
13978
13979   arg1 = (Dali::TouchPoint *)jarg1;
13980   result = (Dali::Vector2 *)& ((arg1)->screen);
13981   jresult = (void *)result;
13982   return jresult;
13983 }
13984
13985
13986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
13987   void * jresult ;
13988   Dali::TouchEvent *result = 0 ;
13989
13990   {
13991     try {
13992       result = (Dali::TouchEvent *)new Dali::TouchEvent();
13993     } CALL_CATCH_EXCEPTION(0);
13994   }
13995
13996   jresult = (void *)result;
13997   return jresult;
13998 }
13999
14000
14001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
14002   void * jresult ;
14003   Dali::TouchEvent *arg1 = 0 ;
14004   Dali::TouchEvent *result = 0 ;
14005
14006   arg1 = (Dali::TouchEvent *)jarg1;
14007   if (!arg1) {
14008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
14009     return 0;
14010   }
14011   {
14012     try {
14013       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
14014     } CALL_CATCH_EXCEPTION(0);
14015   }
14016
14017   jresult = (void *)result;
14018   return jresult;
14019 }
14020
14021
14022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
14023   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14024
14025   arg1 = (Dali::TouchEvent *)jarg1;
14026   {
14027     try {
14028       delete arg1;
14029     } CALL_CATCH_EXCEPTION();
14030   }
14031
14032 }
14033
14034
14035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
14036   void * jresult ;
14037   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14038   Dali::TouchEvent *arg2 = 0 ;
14039   Dali::TouchEvent *result = 0 ;
14040
14041   arg1 = (Dali::TouchEvent *)jarg1;
14042   arg2 = (Dali::TouchEvent *)jarg2;
14043   if (!arg2) {
14044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
14045     return 0;
14046   }
14047   {
14048     try {
14049       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
14050     } CALL_CATCH_EXCEPTION(0);
14051   }
14052
14053   jresult = (void *)result;
14054   return jresult;
14055 }
14056
14057
14058 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
14059   unsigned long jresult ;
14060   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14061   unsigned long result;
14062
14063   arg1 = (Dali::TouchEvent *)jarg1;
14064   {
14065     try {
14066       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
14067     } CALL_CATCH_EXCEPTION(0);
14068   }
14069
14070   jresult = (unsigned long)result;
14071   return jresult;
14072 }
14073
14074
14075 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
14076   unsigned long jresult ;
14077   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14078   std::size_t result;
14079
14080   arg1 = (Dali::TouchEvent *)jarg1;
14081   {
14082     try {
14083       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
14084     } CALL_CATCH_EXCEPTION(0);
14085   }
14086
14087   jresult = (unsigned long)result;
14088   return jresult;
14089 }
14090
14091
14092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
14093   int jresult ;
14094   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14095   std::size_t arg2 ;
14096   int32_t result;
14097
14098   arg1 = (Dali::TouchEvent *)jarg1;
14099   arg2 = (std::size_t)jarg2;
14100   {
14101     try {
14102       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
14103     } CALL_CATCH_EXCEPTION(0);
14104   }
14105
14106   jresult = result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
14112   int jresult ;
14113   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14114   std::size_t arg2 ;
14115   Dali::PointState::Type result;
14116
14117   arg1 = (Dali::TouchEvent *)jarg1;
14118   arg2 = (std::size_t)jarg2;
14119   {
14120     try {
14121       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
14122     } CALL_CATCH_EXCEPTION(0);
14123   }
14124
14125   jresult = (int)result;
14126   return jresult;
14127 }
14128
14129
14130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
14131   void * jresult ;
14132   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14133   std::size_t arg2 ;
14134   Dali::Actor result;
14135
14136   arg1 = (Dali::TouchEvent *)jarg1;
14137   arg2 = (std::size_t)jarg2;
14138   {
14139     try {
14140       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
14141     } CALL_CATCH_EXCEPTION(0);
14142   }
14143
14144   jresult = new Dali::Actor((const Dali::Actor &)result);
14145   return jresult;
14146 }
14147
14148
14149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
14150   void * jresult ;
14151   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14152   std::size_t arg2 ;
14153   Dali::Vector2 *result = 0 ;
14154
14155   arg1 = (Dali::TouchEvent *)jarg1;
14156   arg2 = (std::size_t)jarg2;
14157   {
14158     try {
14159       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
14160     } CALL_CATCH_EXCEPTION(0);
14161   }
14162
14163   jresult = (void *)result;
14164   return jresult;
14165 }
14166
14167
14168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
14169   void * jresult ;
14170   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14171   std::size_t arg2 ;
14172   Dali::Vector2 *result = 0 ;
14173
14174   arg1 = (Dali::TouchEvent *)jarg1;
14175   arg2 = (std::size_t)jarg2;
14176   {
14177     try {
14178       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
14179     } CALL_CATCH_EXCEPTION(0);
14180   }
14181
14182   jresult = (void *)result;
14183   return jresult;
14184 }
14185
14186
14187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
14188   float jresult ;
14189   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14190   std::size_t arg2 ;
14191   float result;
14192
14193   arg1 = (Dali::TouchEvent *)jarg1;
14194   arg2 = (std::size_t)jarg2;
14195   {
14196     try {
14197       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
14198     } CALL_CATCH_EXCEPTION(0);
14199   }
14200
14201   jresult = result;
14202   return jresult;
14203 }
14204
14205
14206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
14207   void * jresult ;
14208   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14209   std::size_t arg2 ;
14210   Dali::Vector2 *result = 0 ;
14211
14212   arg1 = (Dali::TouchEvent *)jarg1;
14213   arg2 = (std::size_t)jarg2;
14214   {
14215     try {
14216       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
14217     } CALL_CATCH_EXCEPTION(0);
14218   }
14219
14220   jresult = (void *)result;
14221   return jresult;
14222 }
14223
14224
14225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
14226   float jresult ;
14227   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14228   std::size_t arg2 ;
14229   float result;
14230
14231   arg1 = (Dali::TouchEvent *)jarg1;
14232   arg2 = (std::size_t)jarg2;
14233   {
14234     try {
14235       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
14236     } CALL_CATCH_EXCEPTION(0);
14237   }
14238
14239   jresult = result;
14240   return jresult;
14241 }
14242
14243
14244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
14245   void * jresult ;
14246   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14247   std::size_t arg2 ;
14248   Dali::Degree result;
14249
14250   arg1 = (Dali::TouchEvent *)jarg1;
14251   arg2 = (std::size_t)jarg2;
14252   {
14253     try {
14254       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
14255     } CALL_CATCH_EXCEPTION(0);
14256   }
14257
14258   jresult = new Dali::Degree((const Dali::Degree &)result);
14259   return jresult;
14260 }
14261
14262
14263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceClass(void * jarg1, unsigned long jarg2) {
14264   int jresult ;
14265   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14266   std::size_t arg2 ;
14267   Dali::Device::Class::Type result;
14268
14269   arg1 = (Dali::TouchEvent *)jarg1;
14270   arg2 = (std::size_t)jarg2;
14271   {
14272     try {
14273       result = ((Dali::TouchEvent const *)arg1)->GetDeviceClass(arg2);
14274     } CALL_CATCH_EXCEPTION(0);
14275   }
14276
14277   jresult = (int)result;
14278   return jresult;
14279 }
14280
14281
14282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceSubclass(void * jarg1, unsigned long jarg2) {
14283   int jresult ;
14284   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14285   std::size_t arg2 ;
14286   Dali::Device::Subclass::Type result;
14287
14288   arg1 = (Dali::TouchEvent *)jarg1;
14289   arg2 = (std::size_t)jarg2;
14290   {
14291     try {
14292       result = ((Dali::TouchEvent const *)arg1)->GetDeviceSubclass(arg2);
14293     } CALL_CATCH_EXCEPTION(0);
14294   }
14295
14296   jresult = (int)result;
14297   return jresult;
14298 }
14299
14300
14301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
14302   int jresult ;
14303   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
14304   std::size_t arg2 ;
14305   Dali::MouseButton::Type result;
14306
14307   arg1 = (Dali::TouchEvent *)jarg1;
14308   arg2 = (std::size_t)jarg2;
14309   {
14310     try {
14311       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
14312     } CALL_CATCH_EXCEPTION(0);
14313   }
14314
14315   jresult = static_cast< int >(result);
14316   return jresult;
14317 }
14318
14319
14320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
14321   void * jresult ;
14322   Dali::GestureDetector *result = 0 ;
14323
14324   {
14325     try {
14326       result = (Dali::GestureDetector *)new Dali::GestureDetector();
14327     } CALL_CATCH_EXCEPTION(0);
14328   }
14329
14330   jresult = (void *)result;
14331   return jresult;
14332 }
14333
14334
14335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
14336   void * jresult ;
14337   Dali::BaseHandle arg1 ;
14338   Dali::BaseHandle *argp1 ;
14339   Dali::GestureDetector result;
14340
14341   argp1 = (Dali::BaseHandle *)jarg1;
14342   if (!argp1) {
14343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
14344     return 0;
14345   }
14346   arg1 = *argp1;
14347   {
14348     try {
14349       result = Dali::GestureDetector::DownCast(arg1);
14350     } CALL_CATCH_EXCEPTION(0);
14351   }
14352
14353   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
14354   return jresult;
14355 }
14356
14357
14358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
14359   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14360
14361   arg1 = (Dali::GestureDetector *)jarg1;
14362   {
14363     try {
14364       delete arg1;
14365     } CALL_CATCH_EXCEPTION();
14366   }
14367
14368 }
14369
14370
14371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
14372   void * jresult ;
14373   Dali::GestureDetector *arg1 = 0 ;
14374   Dali::GestureDetector *result = 0 ;
14375
14376   arg1 = (Dali::GestureDetector *)jarg1;
14377   if (!arg1) {
14378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
14379     return 0;
14380   }
14381   {
14382     try {
14383       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
14384     } CALL_CATCH_EXCEPTION(0);
14385   }
14386
14387   jresult = (void *)result;
14388   return jresult;
14389 }
14390
14391
14392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
14393   void * jresult ;
14394   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14395   Dali::GestureDetector *arg2 = 0 ;
14396   Dali::GestureDetector *result = 0 ;
14397
14398   arg1 = (Dali::GestureDetector *)jarg1;
14399   arg2 = (Dali::GestureDetector *)jarg2;
14400   if (!arg2) {
14401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
14402     return 0;
14403   }
14404   {
14405     try {
14406       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
14407     } CALL_CATCH_EXCEPTION(0);
14408   }
14409
14410   jresult = (void *)result;
14411   return jresult;
14412 }
14413
14414
14415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
14416   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14417   Dali::Actor arg2 ;
14418   Dali::Actor *argp2 ;
14419
14420   arg1 = (Dali::GestureDetector *)jarg1;
14421   argp2 = (Dali::Actor *)jarg2;
14422   if (!argp2) {
14423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14424     return ;
14425   }
14426   arg2 = *argp2;
14427   {
14428     try {
14429       (arg1)->Attach(arg2);
14430     } CALL_CATCH_EXCEPTION();
14431   }
14432
14433 }
14434
14435
14436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
14437   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14438   Dali::Actor arg2 ;
14439   Dali::Actor *argp2 ;
14440
14441   arg1 = (Dali::GestureDetector *)jarg1;
14442   argp2 = (Dali::Actor *)jarg2;
14443   if (!argp2) {
14444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
14445     return ;
14446   }
14447   arg2 = *argp2;
14448   {
14449     try {
14450       (arg1)->Detach(arg2);
14451     } CALL_CATCH_EXCEPTION();
14452   }
14453
14454 }
14455
14456
14457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
14458   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14459
14460   arg1 = (Dali::GestureDetector *)jarg1;
14461   {
14462     try {
14463       (arg1)->DetachAll();
14464     } CALL_CATCH_EXCEPTION();
14465   }
14466
14467 }
14468
14469
14470 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
14471   unsigned long jresult ;
14472   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14473   size_t result;
14474
14475   arg1 = (Dali::GestureDetector *)jarg1;
14476   {
14477     try {
14478       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
14479     } CALL_CATCH_EXCEPTION(0);
14480   }
14481
14482   jresult = (unsigned long)result;
14483   return jresult;
14484 }
14485
14486
14487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
14488   void * jresult ;
14489   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
14490   size_t arg2 ;
14491   Dali::Actor result;
14492
14493   arg1 = (Dali::GestureDetector *)jarg1;
14494   arg2 = (size_t)jarg2;
14495   {
14496     try {
14497       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
14498     } CALL_CATCH_EXCEPTION(0);
14499   }
14500
14501   jresult = new Dali::Actor((const Dali::Actor &)result);
14502   return jresult;
14503 }
14504
14505 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_GestureDetector_FeedTouch(void * jdetector, void * jactor, void * jtouch) {
14506   bool result = false;
14507   Dali::GestureDetector *detector = (Dali::GestureDetector *)jdetector;
14508   Dali::Actor *actor = (Dali::Actor *)jactor;
14509   Dali::TouchEvent *touchEvent = (Dali::TouchEvent *)jtouch;
14510
14511   {
14512     try {
14513       result = ((Dali::GestureDetector *)detector)->FeedTouch(*actor, *touchEvent);
14514     } CALL_CATCH_EXCEPTION(0);
14515   }
14516
14517   return result;
14518 }
14519
14520
14521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
14522   void * jresult ;
14523   Dali::Gesture *arg1 = 0 ;
14524   Dali::Gesture *result = 0 ;
14525
14526   arg1 = (Dali::Gesture *)jarg1;
14527   if (!arg1) {
14528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14529     return 0;
14530   }
14531   {
14532     try {
14533       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
14534     } CALL_CATCH_EXCEPTION(0);
14535   }
14536
14537   jresult = (void *)result;
14538   return jresult;
14539 }
14540
14541
14542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
14543   void * jresult ;
14544   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14545   Dali::Gesture *arg2 = 0 ;
14546   Dali::Gesture *result = 0 ;
14547
14548   arg1 = (Dali::Gesture *)jarg1;
14549   arg2 = (Dali::Gesture *)jarg2;
14550   if (!arg2) {
14551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14552     return 0;
14553   }
14554   {
14555     try {
14556       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
14557     } CALL_CATCH_EXCEPTION(0);
14558   }
14559
14560   jresult = (void *)result;
14561   return jresult;
14562 }
14563
14564
14565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
14566   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14567
14568   arg1 = (Dali::Gesture *)jarg1;
14569   {
14570     try {
14571       delete arg1;
14572     } CALL_CATCH_EXCEPTION();
14573   }
14574
14575 }
14576
14577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
14578   int jresult ;
14579   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14580   Dali::GestureType::Value result;
14581
14582   arg1 = (Dali::Gesture *)jarg1;
14583   result = (Dali::GestureType::Value) ((arg1)->GetType());
14584   jresult = (int)result;
14585   return jresult;
14586 }
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
14589   int jresult ;
14590   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14591   Dali::GestureState result;
14592
14593   arg1 = (Dali::Gesture *)jarg1;
14594   result = (Dali::GestureState) ((arg1)->GetState());
14595   jresult = (int)result;
14596   return jresult;
14597 }
14598
14599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
14600   unsigned int jresult ;
14601   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
14602   unsigned int result;
14603
14604   arg1 = (Dali::Gesture *)jarg1;
14605   result = (unsigned int) ((arg1)->GetTime());
14606   jresult = result;
14607   return jresult;
14608 }
14609
14610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceType_get(void * gesture) {
14611   int jresult ;
14612   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
14613   Dali::GestureSourceType result;
14614
14615   if (!jGesture) {
14616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
14617     return 0;
14618   }
14619   {
14620     try {
14621       result = (Dali::GestureSourceType)jGesture->GetSourceType();
14622     } CALL_CATCH_EXCEPTION(0);
14623   }
14624
14625   jresult = (int)result;
14626   return jresult;
14627 }
14628
14629
14630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_sourceData_get(void * gesture) {
14631   int jresult ;
14632   Dali::Gesture *jGesture = (Dali::Gesture *) gesture;
14633   Dali::GestureSourceData result;
14634
14635   if (!jGesture) {
14636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::gesture const & type is null", 0);
14637     return 0;
14638   }
14639   {
14640     try {
14641       result = (Dali::GestureSourceData)jGesture->GetSourceData();
14642     } CALL_CATCH_EXCEPTION(0);
14643   }
14644
14645   jresult = (int)result;
14646   return jresult;
14647 }
14648
14649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
14650   void * jresult ;
14651   Dali::HoverEvent *result = 0 ;
14652
14653   {
14654     try {
14655       result = (Dali::HoverEvent *)new Dali::HoverEvent();
14656     } CALL_CATCH_EXCEPTION(0);
14657   }
14658
14659   jresult = (void *)result;
14660   return jresult;
14661 }
14662
14663
14664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(void * jarg1) {
14665   void * jresult ;
14666   Dali::HoverEvent *arg1 = 0 ;
14667   Dali::HoverEvent *result = 0 ;
14668
14669   arg1 = (Dali::HoverEvent *)jarg1;
14670   if (!arg1) {
14671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
14672     return 0;
14673   }
14674   {
14675     try {
14676       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
14677     } CALL_CATCH_EXCEPTION(0);
14678   }
14679
14680   jresult = (void *)result;
14681   return jresult;
14682 }
14683
14684
14685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
14686   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14687
14688   arg1 = (Dali::HoverEvent *)jarg1;
14689   {
14690     try {
14691       delete arg1;
14692     } CALL_CATCH_EXCEPTION();
14693   }
14694
14695 }
14696
14697
14698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
14699   void * jresult ;
14700   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14701   Dali::HoverEvent *arg2 = 0 ;
14702   Dali::HoverEvent *result = 0 ;
14703
14704   arg1 = (Dali::HoverEvent *)jarg1;
14705   arg2 = (Dali::HoverEvent *)jarg2;
14706   if (!arg2) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
14708     return 0;
14709   }
14710   {
14711     try {
14712       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
14713     } catch (std::out_of_range& e) {
14714       {
14715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (std::exception& e) {
14718       {
14719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14720       };
14721     } catch (Dali::DaliException e) {
14722       {
14723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14724       };
14725     } catch (...) {
14726       {
14727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14728       };
14729     }
14730   }
14731
14732   jresult = (void *)result;
14733   return jresult;
14734 }
14735
14736
14737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_New(unsigned int jarg1) {
14738   void * jresult ;
14739   unsigned int arg1 ;
14740   Dali::HoverEvent result;
14741
14742   arg1 = (unsigned int)jarg1;
14743   {
14744     try {
14745       result = DevelHoverEvent::New(arg1);
14746     } CALL_CATCH_EXCEPTION(0);
14747   }
14748
14749   jresult = new Dali::HoverEvent((const Dali::HoverEvent &)result);
14750   return jresult;
14751 }
14752
14753
14754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
14755   unsigned long jresult ;
14756   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14757   unsigned long result;
14758
14759   arg1 = (Dali::HoverEvent *)jarg1;
14760   {
14761     try {
14762       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
14763     } catch (std::out_of_range& e) {
14764       {
14765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14766       };
14767     } catch (std::exception& e) {
14768       {
14769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14770       };
14771     } catch (Dali::DaliException e) {
14772       {
14773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14774       };
14775     } catch (...) {
14776       {
14777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14778       };
14779     }
14780   }
14781
14782   jresult = (unsigned long)result;
14783   return jresult;
14784 }
14785
14786
14787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
14788   unsigned long jresult ;
14789   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14790   std::size_t result;
14791
14792   arg1 = (Dali::HoverEvent *)jarg1;
14793   {
14794     try {
14795       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
14796     } catch (std::out_of_range& e) {
14797       {
14798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14799       };
14800     } catch (std::exception& e) {
14801       {
14802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14803       };
14804     } catch (Dali::DaliException e) {
14805       {
14806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14807       };
14808     } catch (...) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14811       };
14812     }
14813   }
14814
14815   jresult = (unsigned long)result;
14816   return jresult;
14817 }
14818
14819
14820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
14821   int jresult ;
14822   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14823   std::size_t arg2 ;
14824   int32_t result;
14825
14826   arg1 = (Dali::HoverEvent *)jarg1;
14827   arg2 = (std::size_t)jarg2;
14828   {
14829     try {
14830       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
14831     } catch (std::out_of_range& e) {
14832       {
14833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14834       };
14835     } catch (std::exception& e) {
14836       {
14837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14838       };
14839     } catch (Dali::DaliException e) {
14840       {
14841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14842       };
14843     } catch (...) {
14844       {
14845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14846       };
14847     }
14848   }
14849
14850   jresult = result;
14851   return jresult;
14852 }
14853
14854
14855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
14856   int jresult ;
14857   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14858   std::size_t arg2 ;
14859   Dali::PointState::Type result;
14860
14861   arg1 = (Dali::HoverEvent *)jarg1;
14862   arg2 = (std::size_t)jarg2;
14863   {
14864     try {
14865       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
14866     } CALL_CATCH_EXCEPTION(0);
14867   }
14868
14869   jresult = (int)result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
14875   void * jresult ;
14876   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14877   std::size_t arg2 ;
14878   Dali::Actor result;
14879
14880   arg1 = (Dali::HoverEvent *)jarg1;
14881   arg2 = (std::size_t)jarg2;
14882   {
14883     try {
14884       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
14885     } catch (std::out_of_range& e) {
14886       {
14887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14888       };
14889     } catch (std::exception& e) {
14890       {
14891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (Dali::DaliException e) {
14894       {
14895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14896       };
14897     } catch (...) {
14898       {
14899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14900       };
14901     }
14902   }
14903
14904   jresult = new Dali::Actor((const Dali::Actor &)result);
14905   return jresult;
14906 }
14907
14908
14909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
14910   void * jresult ;
14911   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14912   std::size_t arg2 ;
14913   Dali::Vector2 *result = 0 ;
14914
14915   arg1 = (Dali::HoverEvent *)jarg1;
14916   arg2 = (std::size_t)jarg2;
14917   {
14918     try {
14919       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
14920     } catch (std::out_of_range& e) {
14921       {
14922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14923       };
14924     } catch (std::exception& e) {
14925       {
14926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14927       };
14928     } catch (Dali::DaliException e) {
14929       {
14930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14931       };
14932     } catch (...) {
14933       {
14934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14935       };
14936     }
14937   }
14938
14939   jresult = (void *)result;
14940   return jresult;
14941 }
14942
14943
14944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
14945   void * jresult ;
14946   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
14947   std::size_t arg2 ;
14948   Dali::Vector2 *result = 0 ;
14949
14950   arg1 = (Dali::HoverEvent *)jarg1;
14951   arg2 = (std::size_t)jarg2;
14952   {
14953     try {
14954       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
14955     } CALL_CATCH_EXCEPTION(0);
14956   }
14957
14958   jresult = (void *)result;
14959   return jresult;
14960 }
14961
14962
14963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
14964   void * jresult ;
14965   Dali::KeyEvent *result = 0 ;
14966
14967   {
14968     try {
14969       result = (Dali::KeyEvent *)new Dali::KeyEvent();
14970     } CALL_CATCH_EXCEPTION(0);
14971   }
14972
14973   jresult = (void *)result;
14974   return jresult;
14975 }
14976
14977
14978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(void * jarg1) {
14979   void * jresult ;
14980   Dali::KeyEvent *arg1 = 0 ;
14981   Dali::KeyEvent *result = 0 ;
14982
14983   arg1 = (Dali::KeyEvent *)jarg1;
14984   if (!arg1) {
14985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
14986     return 0;
14987   }
14988   {
14989     try {
14990       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
14991     } CALL_CATCH_EXCEPTION(0);
14992   }
14993
14994   jresult = (void *)result;
14995   return jresult;
14996 }
14997
14998
14999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
15000   void * jresult ;
15001   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15002   Dali::KeyEvent *arg2 = 0 ;
15003   Dali::KeyEvent *result = 0 ;
15004
15005   arg1 = (Dali::KeyEvent *)jarg1;
15006   arg2 = (Dali::KeyEvent *)jarg2;
15007   if (!arg2) {
15008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
15009     return 0;
15010   }
15011   {
15012     try {
15013       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
15014     } CALL_CATCH_EXCEPTION(0);
15015   }
15016
15017   jresult = (void *)result;
15018   return jresult;
15019 }
15020
15021
15022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_New(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
15023   void * jresult ;
15024   std::string *arg1 = 0 ;
15025   std::string *arg2 = 0 ;
15026   int arg3 ;
15027   int arg4 ;
15028   unsigned long arg5 ;
15029   Dali::KeyEvent::State *arg6 = 0 ;
15030   Dali::KeyEvent::State temp6 ;
15031   Dali::KeyEvent result;
15032
15033   if (!jarg1) {
15034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15035     return 0;
15036   }
15037   std::string arg1_str(jarg1);
15038   arg1 = &arg1_str;
15039   if (!jarg2) {
15040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15041     return 0;
15042   }
15043   std::string arg2_str(jarg2);
15044   arg2 = &arg2_str;
15045   arg3 = (int)jarg3;
15046   arg4 = (int)jarg4;
15047   arg5 = (unsigned long)jarg5;
15048   temp6 = (Dali::KeyEvent::State)jarg6;
15049   arg6 = &temp6;
15050   {
15051     try {
15052       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);
15053     } CALL_CATCH_EXCEPTION(0);
15054   }
15055
15056   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
15057
15058   //argout typemap for const std::string&
15059
15060
15061   //argout typemap for const std::string&
15062
15063   return jresult;
15064 }
15065
15066 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Key_New__SWIG_1()
15067 {
15068   void* jresult;
15069   Dali::KeyEvent result;
15070
15071   {
15072     try
15073     {
15074       result = DevelKeyEvent::New();
15075     } CALL_CATCH_EXCEPTION(0);
15076   }
15077
15078   jresult = new Dali::KeyEvent((const Dali::KeyEvent &)result);
15079
15080   return jresult;
15081 }
15082
15083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
15084   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15085
15086   arg1 = (Dali::KeyEvent *)jarg1;
15087   {
15088     try {
15089       delete arg1;
15090     } CALL_CATCH_EXCEPTION();
15091   }
15092
15093 }
15094
15095
15096 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
15097   bool jresult ;
15098   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15099   bool result;
15100
15101   arg1 = (Dali::KeyEvent *)jarg1;
15102   {
15103     try {
15104       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
15105     } CALL_CATCH_EXCEPTION(0);
15106   }
15107
15108   jresult = result;
15109   return jresult;
15110 }
15111
15112
15113 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
15114   bool jresult ;
15115   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15116   bool result;
15117
15118   arg1 = (Dali::KeyEvent *)jarg1;
15119   {
15120     try {
15121       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
15122     } CALL_CATCH_EXCEPTION(0);
15123   }
15124
15125   jresult = result;
15126   return jresult;
15127 }
15128
15129
15130 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
15131   bool jresult ;
15132   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
15133   bool result;
15134
15135   arg1 = (Dali::KeyEvent *)jarg1;
15136   {
15137     try {
15138       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
15139     } CALL_CATCH_EXCEPTION(0);
15140   }
15141
15142   jresult = result;
15143   return jresult;
15144 }
15145
15146
15147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
15148   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15149   std::string *arg2 = 0 ;
15150
15151   argp1 = (Dali::KeyEvent *) jarg1;
15152   if (!argp1) {
15153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15154     return ;
15155   }
15156
15157   Dali::KeyEvent arg1 = *argp1;
15158   if (!jarg2) {
15159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15160     return ;
15161   }
15162   std::string arg2_str(jarg2);
15163   arg2 = &arg2_str;
15164
15165   {
15166     try {
15167       Dali::DevelKeyEvent::SetKeyName(arg1, (std::string const &)*arg2);
15168     } catch (std::out_of_range& e) {
15169       {
15170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15171       };
15172     } catch (std::exception& e) {
15173       {
15174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15175       };
15176     } catch (Dali::DaliException e) {
15177       {
15178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15179       };
15180     } catch (...) {
15181       {
15182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15183       };
15184     }
15185   }
15186 }
15187
15188
15189 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
15190   char * jresult ;
15191
15192   if( jarg1 == NULL )
15193   {
15194     jresult = SWIG_csharp_string_callback( "" );
15195   }
15196   else
15197   {
15198     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15199     std::string *result = 0;
15200     std::string str = "";
15201
15202     arg1 = ( Dali::KeyEvent * )jarg1;
15203     {
15204       try {
15205         str = ((Dali::KeyEvent const *)arg1)->GetKeyName();
15206         result = (std::string *) &str;
15207         jresult = SWIG_csharp_string_callback(result->c_str());
15208       } catch (std::out_of_range& e) {
15209         {
15210           SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15211         };
15212       } catch (std::exception& e) {
15213         {
15214           SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15215         };
15216       } catch (Dali::DaliException e) {
15217         {
15218           SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15219         };
15220       } catch (...) {
15221         {
15222           SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15223         };
15224       }
15225     }
15226
15227   }
15228
15229   return jresult;
15230 }
15231
15232
15233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
15234   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15235   std::string *arg2 = 0 ;
15236
15237   argp1 = (Dali::KeyEvent *) jarg1;
15238   if (!argp1) {
15239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15240     return ;
15241   }
15242
15243   Dali::KeyEvent arg1 = *argp1;
15244   if (!jarg2) {
15245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15246     return ;
15247   }
15248   std::string arg2_str(jarg2);
15249   arg2 = &arg2_str;
15250
15251   {
15252     try {
15253       Dali::DevelKeyEvent::SetKeyString(arg1, (std::string const &)*arg2);
15254     } catch (std::out_of_range& e) {
15255       {
15256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15257       };
15258     } catch (std::exception& e) {
15259       {
15260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15261       };
15262     } catch (Dali::DaliException e) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15265       };
15266     } catch (...) {
15267       {
15268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15269       };
15270     }
15271   }
15272 }
15273
15274
15275 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
15276   char * jresult ;
15277
15278   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15279   std::string *result = 0;
15280   std::string str = "";
15281   arg1 = ( Dali::KeyEvent * )jarg1;
15282   {
15283     try {
15284       str = ((Dali::KeyEvent const *)arg1)->GetKeyString();
15285       result = (std::string *) &str;
15286       jresult = SWIG_csharp_string_callback(result->c_str());
15287     } catch (std::out_of_range& e) {
15288       {
15289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15290       };
15291     } catch (std::exception& e) {
15292       {
15293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15294       };
15295     } catch (Dali::DaliException e) {
15296       {
15297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15298       };
15299     } catch (...) {
15300       {
15301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15302       };
15303     }
15304   }
15305
15306   return jresult;
15307 }
15308
15309
15310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
15311   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15312   int arg2 ;
15313
15314   argp1 = (Dali::KeyEvent *) jarg1;
15315   if (!argp1) {
15316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15317     return ;
15318   }
15319
15320   Dali::KeyEvent arg1 = *argp1;
15321   arg2 = (int)jarg2;
15322   {
15323     try {
15324       Dali::DevelKeyEvent::SetKeyCode(arg1, arg2);
15325     } catch (std::out_of_range& e) {
15326       {
15327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15328       };
15329     } catch (std::exception& e) {
15330       {
15331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15332       };
15333     } catch (Dali::DaliException e) {
15334       {
15335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15336       };
15337     } catch (...) {
15338       {
15339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15340       };
15341     }
15342   }
15343 }
15344
15345
15346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
15347   int jresult ;
15348   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15349   int result;
15350
15351   arg1 = (Dali::KeyEvent *)jarg1;
15352   {
15353     try {
15354       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyCode();
15355     } catch (std::out_of_range& e) {
15356       {
15357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15358       };
15359     } catch (std::exception& e) {
15360       {
15361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15362       };
15363     } catch (Dali::DaliException e) {
15364       {
15365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15366       };
15367     } catch (...) {
15368       {
15369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15370       };
15371     }
15372   }
15373
15374   jresult = result;
15375   return jresult;
15376 }
15377
15378
15379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
15380   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15381   int arg2 ;
15382
15383   argp1 = (Dali::KeyEvent *) jarg1;
15384   if (!argp1) {
15385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15386     return ;
15387   }
15388
15389   Dali::KeyEvent arg1 = *argp1;
15390   arg2 = (int)jarg2;
15391   {
15392     try {
15393       Dali::DevelKeyEvent::SetKeyModifier(arg1, arg2);
15394     } catch (std::out_of_range& e) {
15395       {
15396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15397       };
15398     } catch (std::exception& e) {
15399       {
15400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15401       };
15402     } catch (Dali::DaliException e) {
15403       {
15404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15405       };
15406     } catch (...) {
15407       {
15408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15409       };
15410     }
15411   }
15412 }
15413
15414
15415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
15416   int jresult ;
15417   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15418   int result;
15419
15420   arg1 = (Dali::KeyEvent *)jarg1;
15421   {
15422     try {
15423       result = (int)((Dali::KeyEvent const *)arg1)->GetKeyModifier();
15424     } catch (std::out_of_range& e) {
15425       {
15426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15427       };
15428     } catch (std::exception& e) {
15429       {
15430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15431       };
15432     } catch (Dali::DaliException e) {
15433       {
15434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15435       };
15436     } catch (...) {
15437       {
15438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15439       };
15440     }
15441   }
15442
15443   jresult = result;
15444   return jresult;
15445 }
15446
15447
15448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
15449   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0 ;
15450   unsigned long arg2 ;
15451
15452   argp1 = (Dali::KeyEvent *) jarg1;
15453   if (!argp1) {
15454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15455     return ;
15456   }
15457
15458   Dali::KeyEvent arg1 = *argp1;
15459   arg2 = (int)jarg2;
15460   {
15461     try {
15462       Dali::DevelKeyEvent::SetTime(arg1, arg2);
15463     } catch (std::out_of_range& e) {
15464       {
15465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15466       };
15467     } catch (std::exception& e) {
15468       {
15469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15470       };
15471     } catch (Dali::DaliException e) {
15472       {
15473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15474       };
15475     } catch (...) {
15476       {
15477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15478       };
15479     }
15480   }
15481 }
15482
15483
15484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
15485   unsigned long jresult ;
15486   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15487   unsigned long result;
15488
15489   arg1 = (Dali::KeyEvent *)jarg1;
15490   {
15491     try {
15492       result = (int)((Dali::KeyEvent const *)arg1)->GetTime();
15493     } catch (std::out_of_range& e) {
15494       {
15495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15496       };
15497     } catch (std::exception& e) {
15498       {
15499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15500       };
15501     } catch (Dali::DaliException e) {
15502       {
15503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15504       };
15505     } catch (...) {
15506       {
15507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15508       };
15509     }
15510   }
15511
15512   jresult = result;
15513   return jresult;
15514 }
15515
15516
15517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
15518   Dali::KeyEvent *argp1 = (Dali::KeyEvent *) 0;
15519   Dali::KeyEvent::State arg2;
15520
15521   argp1 = (Dali::KeyEvent *) jarg1;
15522   if (!argp1) {
15523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "KeyEvent is null", 0);
15524     return ;
15525   }
15526
15527   Dali::KeyEvent arg1 = *argp1;
15528   arg2 = (Dali::KeyEvent::State)jarg2;
15529   {
15530     try {
15531       Dali::DevelKeyEvent::SetState(arg1, arg2);
15532     } catch (std::out_of_range& e) {
15533       {
15534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15535       };
15536     } catch (std::exception& e) {
15537       {
15538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15539       };
15540     } catch (Dali::DaliException e) {
15541       {
15542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15543       };
15544     } catch (...) {
15545       {
15546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15547       };
15548     }
15549   }
15550 }
15551
15552
15553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
15554   int jresult ;
15555   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15556   Dali::KeyEvent::State result;
15557
15558   arg1 = (Dali::KeyEvent *)jarg1;
15559   {
15560     try {
15561       result = (Dali::KeyEvent::State)((Dali::KeyEvent const *)arg1)->GetState();
15562     } catch (std::out_of_range& e) {
15563       {
15564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15565       };
15566     } catch (std::exception& e) {
15567       {
15568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15569       };
15570     } catch (Dali::DaliException e) {
15571       {
15572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15573       };
15574     } catch (...) {
15575       {
15576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15577       };
15578     }
15579   }
15580
15581   jresult = (int)result;
15582   return jresult;
15583
15584 }
15585
15586 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
15587   char * jresult ;
15588
15589   Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
15590   std::string *result = 0;
15591   std::string str = "";
15592
15593   arg1 = ( Dali::KeyEvent * )jarg1;
15594   {
15595     try {
15596       str = ((Dali::KeyEvent const *)arg1)->GetLogicalKey();
15597       result = (std::string *) &str;
15598       jresult = SWIG_csharp_string_callback(result->c_str());
15599     } CALL_CATCH_EXCEPTION(0);
15600   }
15601
15602   return jresult;
15603 }
15604
15605
15606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
15607   void * jresult ;
15608   Dali::LongPressGestureDetector *result = 0 ;
15609
15610   {
15611     try {
15612       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
15613     } CALL_CATCH_EXCEPTION(0);
15614   }
15615
15616   jresult = (void *)result;
15617   return jresult;
15618 }
15619
15620
15621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
15622   void * jresult ;
15623   Dali::LongPressGestureDetector result;
15624
15625   {
15626     try {
15627       result = Dali::LongPressGestureDetector::New();
15628     } CALL_CATCH_EXCEPTION(0);
15629   }
15630
15631   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
15632   return jresult;
15633 }
15634
15635
15636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
15637   void * jresult ;
15638   unsigned int arg1 ;
15639   Dali::LongPressGestureDetector result;
15640
15641   arg1 = (unsigned int)jarg1;
15642   {
15643     try {
15644       result = Dali::LongPressGestureDetector::New(arg1);
15645     } CALL_CATCH_EXCEPTION(0);
15646   }
15647
15648   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
15649   return jresult;
15650 }
15651
15652
15653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
15654   void * jresult ;
15655   unsigned int arg1 ;
15656   unsigned int arg2 ;
15657   Dali::LongPressGestureDetector result;
15658
15659   arg1 = (unsigned int)jarg1;
15660   arg2 = (unsigned int)jarg2;
15661   {
15662     try {
15663       result = Dali::LongPressGestureDetector::New(arg1,arg2);
15664     } CALL_CATCH_EXCEPTION(0);
15665   }
15666
15667   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
15668   return jresult;
15669 }
15670
15671
15672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
15673   void * jresult ;
15674   Dali::BaseHandle arg1 ;
15675   Dali::BaseHandle *argp1 ;
15676   Dali::LongPressGestureDetector result;
15677
15678   argp1 = (Dali::BaseHandle *)jarg1;
15679   if (!argp1) {
15680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
15681     return 0;
15682   }
15683   arg1 = *argp1;
15684   {
15685     try {
15686       result = Dali::LongPressGestureDetector::DownCast(arg1);
15687     } CALL_CATCH_EXCEPTION(0);
15688   }
15689
15690   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
15691   return jresult;
15692 }
15693
15694
15695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
15696   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15697
15698   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15699   {
15700     try {
15701       delete arg1;
15702     } CALL_CATCH_EXCEPTION();
15703   }
15704
15705 }
15706
15707
15708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
15709   void * jresult ;
15710   Dali::LongPressGestureDetector *arg1 = 0 ;
15711   Dali::LongPressGestureDetector *result = 0 ;
15712
15713   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15714   if (!arg1) {
15715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
15716     return 0;
15717   }
15718   {
15719     try {
15720       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
15721     } CALL_CATCH_EXCEPTION(0);
15722   }
15723
15724   jresult = (void *)result;
15725   return jresult;
15726 }
15727
15728
15729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
15730   void * jresult ;
15731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15732   Dali::LongPressGestureDetector *arg2 = 0 ;
15733   Dali::LongPressGestureDetector *result = 0 ;
15734
15735   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15736   arg2 = (Dali::LongPressGestureDetector *)jarg2;
15737   if (!arg2) {
15738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
15739     return 0;
15740   }
15741   {
15742     try {
15743       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
15744     } CALL_CATCH_EXCEPTION(0);
15745   }
15746
15747   jresult = (void *)result;
15748   return jresult;
15749 }
15750
15751
15752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
15753   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15754   unsigned int arg2 ;
15755
15756   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15757   arg2 = (unsigned int)jarg2;
15758   {
15759     try {
15760       (arg1)->SetTouchesRequired(arg2);
15761     } CALL_CATCH_EXCEPTION();
15762   }
15763
15764 }
15765
15766
15767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
15768   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15769   unsigned int arg2 ;
15770   unsigned int arg3 ;
15771
15772   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15773   arg2 = (unsigned int)jarg2;
15774   arg3 = (unsigned int)jarg3;
15775   {
15776     try {
15777       (arg1)->SetTouchesRequired(arg2,arg3);
15778     } CALL_CATCH_EXCEPTION();
15779   }
15780
15781 }
15782
15783
15784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
15785   unsigned int jresult ;
15786   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15787   unsigned int result;
15788
15789   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15790   {
15791     try {
15792       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
15793     } CALL_CATCH_EXCEPTION(0);
15794   }
15795
15796   jresult = result;
15797   return jresult;
15798 }
15799
15800
15801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
15802   unsigned int jresult ;
15803   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15804   unsigned int result;
15805
15806   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15807   {
15808     try {
15809       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
15810     } CALL_CATCH_EXCEPTION(0);
15811   }
15812
15813   jresult = result;
15814   return jresult;
15815 }
15816
15817
15818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
15819   void * jresult ;
15820   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
15821   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
15822
15823   arg1 = (Dali::LongPressGestureDetector *)jarg1;
15824   {
15825     try {
15826       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
15827     } CALL_CATCH_EXCEPTION(0);
15828   }
15829
15830   jresult = (void *)result;
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0() {
15836   void * jresult ;
15837   Dali::LongPressGesture *result = 0 ;
15838
15839   {
15840     try {
15841       result = (Dali::LongPressGesture *)new Dali::LongPressGesture();
15842     } CALL_CATCH_EXCEPTION(0);
15843   }
15844
15845   jresult = (void *)result;
15846   return jresult;
15847 }
15848
15849
15850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_New(int jarg1) {
15851   void * jresult ;
15852   Dali::GestureState arg1 ;
15853   Dali::LongPressGesture result;
15854
15855   arg1 = (Dali::GestureState)jarg1;
15856   {
15857     try {
15858       result = DevelLongPressGesture::New(arg1);
15859     } CALL_CATCH_EXCEPTION(0);
15860   }
15861
15862   jresult = new Dali::LongPressGesture((const Dali::LongPressGesture &)result);
15863   return jresult;
15864 }
15865
15866
15867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
15868   void * jresult ;
15869   Dali::LongPressGesture *arg1 = 0 ;
15870   Dali::LongPressGesture *result = 0 ;
15871
15872   arg1 = (Dali::LongPressGesture *)jarg1;
15873   if (!arg1) {
15874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
15875     return 0;
15876   }
15877   {
15878     try {
15879       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
15880     } CALL_CATCH_EXCEPTION(0);
15881   }
15882
15883   jresult = (void *)result;
15884   return jresult;
15885 }
15886
15887
15888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
15889   void * jresult ;
15890   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
15891   Dali::LongPressGesture *arg2 = 0 ;
15892   Dali::LongPressGesture *result = 0 ;
15893
15894   arg1 = (Dali::LongPressGesture *)jarg1;
15895   arg2 = (Dali::LongPressGesture *)jarg2;
15896   if (!arg2) {
15897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
15898     return 0;
15899   }
15900   {
15901     try {
15902       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
15903     } CALL_CATCH_EXCEPTION(0);
15904   }
15905
15906   jresult = (void *)result;
15907   return jresult;
15908 }
15909
15910
15911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
15912   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
15913
15914   arg1 = (Dali::LongPressGesture *)jarg1;
15915   {
15916     try {
15917       delete arg1;
15918     } CALL_CATCH_EXCEPTION();
15919   }
15920
15921 }
15922
15923
15924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
15925   unsigned int jresult ;
15926   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
15927   unsigned int result;
15928
15929   arg1 = (Dali::LongPressGesture *)jarg1;
15930   result = (unsigned int) ((arg1)->GetNumberOfTouches());
15931   jresult = result;
15932   return jresult;
15933 }
15934
15935
15936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
15937   void * jresult ;
15938   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
15939   Dali::Vector2 result;
15940
15941   arg1 = (Dali::LongPressGesture *)jarg1;
15942   {
15943     try {
15944       result = ((Dali::LongPressGesture const *)arg1)->GetScreenPoint();
15945     } catch (std::out_of_range& e) {
15946       {
15947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15948       };
15949     } catch (std::exception& e) {
15950       {
15951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (Dali::DaliException e) {
15954       {
15955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15956       };
15957     } catch (...) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15960       };
15961     }
15962   }
15963   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
15964   return jresult;
15965 }
15966
15967
15968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
15969   void * jresult ;
15970   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
15971   Dali::Vector2 result;
15972
15973   arg1 = (Dali::LongPressGesture *)jarg1;
15974   {
15975     try {
15976       result = ((Dali::LongPressGesture const *)arg1)->GetLocalPoint();
15977     } catch (std::out_of_range& e) {
15978       {
15979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15980       };
15981     } catch (std::exception& e) {
15982       {
15983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15984       };
15985     } catch (Dali::DaliException e) {
15986       {
15987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15988       };
15989     } catch (...) {
15990       {
15991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15992       };
15993     }
15994   }
15995   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
15996   return jresult;
15997 }
15998
15999
16000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
16001   void * jresult ;
16002   Dali::WheelEvent *result = 0 ;
16003
16004   {
16005     try {
16006       result = (Dali::WheelEvent *)new Dali::WheelEvent();
16007     } CALL_CATCH_EXCEPTION(0);
16008   }
16009
16010   jresult = (void *)result;
16011   return jresult;
16012 }
16013
16014
16015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(void * jarg1) {
16016   void * jresult ;
16017   Dali::WheelEvent *arg1 = 0 ;
16018   Dali::WheelEvent *result = 0 ;
16019
16020   arg1 = (Dali::WheelEvent *)jarg1;
16021   if (!arg1) {
16022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
16023     return 0;
16024   }
16025   {
16026     try {
16027       result = (Dali::WheelEvent *)new Dali::WheelEvent((Dali::WheelEvent const &)*arg1);
16028     } catch (std::out_of_range& e) {
16029       {
16030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16031       };
16032     } catch (std::exception& e) {
16033       {
16034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16035       };
16036     } catch (Dali::DaliException e) {
16037       {
16038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16039       };
16040     } catch (...) {
16041       {
16042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16043       };
16044     }
16045   }
16046
16047   jresult = (void *)result;
16048   return jresult;
16049 }
16050
16051
16052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_Assign(void * jarg1, void * jarg2) {
16053   void * jresult ;
16054   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16055   Dali::WheelEvent *arg2 = 0 ;
16056   Dali::WheelEvent *result = 0 ;
16057
16058   arg1 = (Dali::WheelEvent *)jarg1;
16059   arg2 = (Dali::WheelEvent *)jarg2;
16060   if (!arg2) {
16061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
16062     return 0;
16063   }
16064   {
16065     try {
16066       result = (Dali::WheelEvent *) &(arg1)->operator =((Dali::WheelEvent const &)*arg2);
16067     } catch (std::out_of_range& e) {
16068       {
16069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16070       };
16071     } catch (std::exception& e) {
16072       {
16073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16074       };
16075     } catch (Dali::DaliException e) {
16076       {
16077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16078       };
16079     } catch (...) {
16080       {
16081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16082       };
16083     }
16084   }
16085
16086   jresult = (void *)result;
16087   return jresult;
16088 }
16089
16090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_New(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
16091   void * jresult ;
16092   Dali::WheelEvent::Type arg1 ;
16093   int arg2 ;
16094   unsigned int arg3 ;
16095   Dali::Vector2 arg4 ;
16096   int arg5 ;
16097   unsigned int arg6 ;
16098   Dali::Vector2 *argp4 ;
16099   Dali::WheelEvent result;
16100
16101   arg1 = (Dali::WheelEvent::Type)jarg1;
16102   arg2 = (int)jarg2;
16103   arg3 = (unsigned int)jarg3;
16104   argp4 = (Dali::Vector2 *)jarg4;
16105   if (!argp4) {
16106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
16107     return 0;
16108   }
16109   arg4 = *argp4;
16110   arg5 = (int)jarg5;
16111   arg6 = (unsigned int)jarg6;
16112   {
16113     try {
16114       result = DevelWheelEvent::New(arg1,arg2,arg3,arg4,arg5,arg6);
16115     } CALL_CATCH_EXCEPTION(0);
16116   }
16117
16118   jresult = new Dali::WheelEvent((const Dali::WheelEvent &)result);
16119   return jresult;
16120 }
16121
16122
16123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
16124   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16125
16126   arg1 = (Dali::WheelEvent *)jarg1;
16127   {
16128     try {
16129       delete arg1;
16130     } CALL_CATCH_EXCEPTION();
16131   }
16132
16133 }
16134
16135
16136 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
16137   bool jresult ;
16138   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16139   bool result;
16140
16141   arg1 = (Dali::WheelEvent *)jarg1;
16142   {
16143     try {
16144       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
16145     } CALL_CATCH_EXCEPTION(0);
16146   }
16147
16148   jresult = result;
16149   return jresult;
16150 }
16151
16152
16153 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
16154   bool jresult ;
16155   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16156   bool result;
16157
16158   arg1 = (Dali::WheelEvent *)jarg1;
16159   {
16160     try {
16161       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
16162     } catch (std::out_of_range& e) {
16163       {
16164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16165       };
16166     } catch (std::exception& e) {
16167       {
16168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16169       };
16170     } catch (Dali::DaliException e) {
16171       {
16172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16173       };
16174     } catch (...) {
16175       {
16176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16177       };
16178     }
16179   }
16180
16181   jresult = result;
16182   return jresult;
16183 }
16184
16185
16186 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
16187   bool jresult ;
16188   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16189   bool result;
16190
16191   arg1 = (Dali::WheelEvent *)jarg1;
16192   {
16193     try {
16194       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
16195     } catch (std::out_of_range& e) {
16196       {
16197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16198       };
16199     } catch (std::exception& e) {
16200       {
16201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16202       };
16203     } catch (Dali::DaliException e) {
16204       {
16205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16206       };
16207     } catch (...) {
16208       {
16209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16210       };
16211     }
16212   }
16213
16214   jresult = result;
16215   return jresult;
16216 }
16217
16218
16219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
16220   int jresult ;
16221   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16222   Dali::WheelEvent::Type result;
16223
16224   arg1 = (Dali::WheelEvent *)jarg1;
16225   {
16226     try {
16227       result = ((Dali::WheelEvent const *)arg1)->GetType();
16228     } catch (std::out_of_range& e) {
16229       {
16230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16231       };
16232     } catch (std::exception& e) {
16233       {
16234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16235       };
16236     } catch (Dali::DaliException e) {
16237       {
16238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16239       };
16240     } catch (...) {
16241       {
16242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16243       };
16244     }
16245   }
16246
16247   jresult = (int)result;
16248   return jresult;
16249 }
16250
16251
16252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
16253   int jresult ;
16254   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16255   int result;
16256
16257   arg1 = (Dali::WheelEvent *)jarg1;
16258   {
16259     try {
16260       result = ((Dali::WheelEvent const *)arg1)->GetDirection();
16261     } catch (std::out_of_range& e) {
16262       {
16263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16264       };
16265     } catch (std::exception& e) {
16266       {
16267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16268       };
16269     } catch (Dali::DaliException e) {
16270       {
16271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16272       };
16273     } catch (...) {
16274       {
16275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16276       };
16277     }
16278   }
16279
16280   jresult = result;
16281   return jresult;
16282 }
16283
16284
16285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
16286   unsigned int jresult ;
16287   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16288   unsigned int result;
16289
16290   arg1 = (Dali::WheelEvent *)jarg1;
16291   {
16292     try {
16293       result = ((Dali::WheelEvent const *)arg1)->GetModifiers();
16294     } CALL_CATCH_EXCEPTION(0);
16295   }
16296
16297   jresult = result;
16298   return jresult;
16299 }
16300
16301
16302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
16303   void * jresult ;
16304   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16305   Dali::Vector2 *result = 0 ;
16306
16307   arg1 = (Dali::WheelEvent *)jarg1;
16308   {
16309     try {
16310       result = (Dali::Vector2 *) &((Dali::WheelEvent const *)arg1)->GetPoint();
16311     } CALL_CATCH_EXCEPTION(0);
16312   }
16313
16314   jresult = (void *)result;
16315   return jresult;
16316 }
16317
16318
16319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_delta_get(void * jarg1) {
16320   int jresult ;
16321   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16322   int result;
16323
16324   arg1 = (Dali::WheelEvent *)jarg1;
16325   {
16326     try {
16327       result = ((Dali::WheelEvent const *)arg1)->GetDelta();
16328     } catch (std::out_of_range& e) {
16329       {
16330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16331       };
16332     } catch (std::exception& e) {
16333       {
16334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16335       };
16336     } catch (Dali::DaliException e) {
16337       {
16338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16339       };
16340     } catch (...) {
16341       {
16342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16343       };
16344     }
16345   }
16346
16347   jresult = result;
16348   return jresult;
16349 }
16350
16351
16352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
16353   unsigned int jresult ;
16354   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
16355   unsigned int result;
16356
16357   arg1 = (Dali::WheelEvent *)jarg1;
16358   {
16359     try {
16360       result = ((Dali::WheelEvent const *)arg1)->GetTime();
16361     } catch (std::out_of_range& e) {
16362       {
16363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (std::exception& e) {
16366       {
16367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (Dali::DaliException e) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16372       };
16373     } catch (...) {
16374       {
16375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16376       };
16377     }
16378   }
16379
16380   jresult = result;
16381   return jresult;
16382 }
16383
16384 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
16385   char * jresult ;
16386   Dali::KeyEvent *arg1 = 0 ;
16387   std::string result;
16388
16389   arg1 = (Dali::KeyEvent *)jarg1;
16390   if (!arg1) {
16391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16392     return 0;
16393   }
16394   {
16395     try {
16396       result = arg1->GetDeviceName();
16397     } CALL_CATCH_EXCEPTION(0);
16398   }
16399
16400   jresult = SWIG_csharp_string_callback((&result)->c_str());
16401   return jresult;
16402 }
16403
16404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
16405   int jresult ;
16406   Dali::KeyEvent *arg1 = 0 ;
16407   Dali::Device::Class::Type result;
16408
16409   arg1 = (Dali::KeyEvent *)jarg1;
16410   if (!arg1) {
16411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16412     return 0;
16413   }
16414   {
16415     try {
16416       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
16417     } CALL_CATCH_EXCEPTION(0);
16418   }
16419
16420   jresult = (int)result;
16421   return jresult;
16422 }
16423
16424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
16425   int jresult ;
16426   Dali::KeyEvent *arg1 = 0 ;
16427   Dali::Device::Subclass::Type result;
16428
16429   arg1 = (Dali::KeyEvent *)jarg1;
16430   if (!arg1) {
16431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
16432     return 0;
16433   }
16434   {
16435     try {
16436       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
16437     } CALL_CATCH_EXCEPTION(0);
16438   }
16439
16440   jresult = (int)result;
16441   return jresult;
16442 }
16443
16444
16445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
16446   void * jresult ;
16447   Dali::Stage result;
16448
16449   {
16450     try {
16451       result = Dali::Stage::GetCurrent();
16452     } CALL_CATCH_EXCEPTION(0);
16453   }
16454
16455   jresult = new Dali::Stage((const Dali::Stage &)result);
16456   return jresult;
16457 }
16458
16459
16460 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
16461   bool jresult ;
16462   bool result;
16463
16464   {
16465     try {
16466       result = (bool)Dali::Stage::IsInstalled();
16467     } CALL_CATCH_EXCEPTION(0);
16468   }
16469
16470   jresult = result;
16471   return jresult;
16472 }
16473
16474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
16475   void * jresult ;
16476   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16477   Dali::RenderTaskList result;
16478
16479   arg1 = (Dali::Stage *)jarg1;
16480   {
16481     try {
16482       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
16483     } CALL_CATCH_EXCEPTION(0);
16484   }
16485
16486   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
16487   return jresult;
16488 }
16489
16490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
16491   void * jresult ;
16492   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16493   Dali::Vector2 result;
16494
16495   arg1 = (Dali::Stage *)jarg1;
16496   {
16497     try {
16498       result = ((Dali::Stage const *)arg1)->GetDpi();
16499     } CALL_CATCH_EXCEPTION(0);
16500   }
16501
16502   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
16503   return jresult;
16504 }
16505
16506
16507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
16508   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16509   float arg2 ;
16510
16511   arg1 = (Dali::Stage *)jarg1;
16512   arg2 = (float)jarg2;
16513   {
16514     try {
16515       (arg1)->KeepRendering(arg2);
16516     } CALL_CATCH_EXCEPTION();
16517   }
16518
16519 }
16520
16521
16522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
16523   void * jresult ;
16524   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16525   Dali::Stage::KeyEventSignalType *result = 0 ;
16526
16527   arg1 = (Dali::Stage *)jarg1;
16528   {
16529     try {
16530       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
16531     } CALL_CATCH_EXCEPTION(0);
16532   }
16533
16534   jresult = (void *)result;
16535   return jresult;
16536 }
16537
16538
16539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
16540   void * jresult ;
16541   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16542   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
16543
16544   arg1 = (Dali::Stage *)jarg1;
16545   {
16546     try {
16547       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
16548     } CALL_CATCH_EXCEPTION(0);
16549   }
16550
16551   jresult = (void *)result;
16552   return jresult;
16553 }
16554
16555
16556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
16557   void * jresult ;
16558   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16559   Dali::Stage::TouchEventSignalType *result = 0 ;
16560
16561   arg1 = (Dali::Stage *)jarg1;
16562   {
16563     try {
16564       result = (Dali::Stage::TouchEventSignalType *) &(arg1)->TouchedSignal();
16565     } CALL_CATCH_EXCEPTION(0);
16566   }
16567
16568   jresult = (void *)result;
16569   return jresult;
16570 }
16571
16572
16573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
16574   void * jresult ;
16575   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16576   Dali::Stage::WheelEventSignalType *result = 0 ;
16577
16578   arg1 = (Dali::Stage *)jarg1;
16579   {
16580     try {
16581       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
16582     } CALL_CATCH_EXCEPTION(0);
16583   }
16584
16585   jresult = (void *)result;
16586   return jresult;
16587 }
16588
16589
16590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
16591   void * jresult ;
16592   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16593   Dali::Stage::ContextStatusSignal *result = 0 ;
16594
16595   arg1 = (Dali::Stage *)jarg1;
16596   {
16597     try {
16598       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
16599     } CALL_CATCH_EXCEPTION(0);
16600   }
16601
16602   jresult = (void *)result;
16603   return jresult;
16604 }
16605
16606
16607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
16608   void * jresult ;
16609   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16610   Dali::Stage::ContextStatusSignal *result = 0 ;
16611
16612   arg1 = (Dali::Stage *)jarg1;
16613   {
16614     try {
16615       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
16616     } CALL_CATCH_EXCEPTION(0);
16617   }
16618
16619   jresult = (void *)result;
16620   return jresult;
16621 }
16622
16623
16624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
16625   void * jresult ;
16626   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16627   Dali::Stage::SceneCreatedSignalType *result = 0 ;
16628
16629   arg1 = (Dali::Stage *)jarg1;
16630   {
16631     try {
16632       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
16633     } CALL_CATCH_EXCEPTION(0);
16634   }
16635
16636   jresult = (void *)result;
16637   return jresult;
16638 }
16639
16640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
16641   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16642   Dali::DevelStage::Rendering arg2 ;
16643
16644   arg1 = (Dali::Stage *)jarg1;
16645   arg2 = (Dali::DevelStage::Rendering)jarg2;
16646   {
16647     try {
16648       DevelStage::SetRenderingBehavior(*arg1,arg2);
16649     } CALL_CATCH_EXCEPTION();
16650   }
16651
16652 }
16653
16654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
16655
16656   int jresult ;
16657   int result ;
16658   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
16659
16660   arg1 = (Dali::Stage *)jarg1;
16661   {
16662     try {
16663       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
16664     } CALL_CATCH_EXCEPTION(0);
16665   }
16666
16667   jresult = result;
16668   return jresult;
16669 }
16670
16671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
16672   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
16673
16674   arg1 = (Dali::RelayoutContainer *)jarg1;
16675   {
16676     try {
16677       delete arg1;
16678     } CALL_CATCH_EXCEPTION();
16679   }
16680
16681 }
16682
16683
16684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
16685   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
16686   Dali::Actor *arg2 = 0 ;
16687   Dali::Vector2 *arg3 = 0 ;
16688
16689   arg1 = (Dali::RelayoutContainer *)jarg1;
16690   arg2 = (Dali::Actor *)jarg2;
16691   if (!arg2) {
16692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
16693     return ;
16694   }
16695   arg3 = (Dali::Vector2 *)jarg3;
16696   if (!arg3) {
16697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16698     return ;
16699   }
16700   {
16701     try {
16702       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
16703     } CALL_CATCH_EXCEPTION();
16704   }
16705
16706 }
16707
16708
16709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
16710   void * jresult ;
16711   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16712   Dali::CustomActor result;
16713
16714   arg1 = (Dali::CustomActorImpl *)jarg1;
16715   {
16716     try {
16717       result = ((Dali::CustomActorImpl const *)arg1)->Self();
16718     } CALL_CATCH_EXCEPTION(0);
16719   }
16720
16721   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
16722   return jresult;
16723 }
16724
16725
16726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
16727   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16728   int arg2 ;
16729
16730   arg1 = (Dali::CustomActorImpl *)jarg1;
16731   arg2 = (int)jarg2;
16732   {
16733     try {
16734       (arg1)->OnSceneConnection(arg2);
16735     } CALL_CATCH_EXCEPTION();
16736   }
16737
16738 }
16739
16740
16741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
16742   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16743
16744   arg1 = (Dali::CustomActorImpl *)jarg1;
16745   {
16746     try {
16747       (arg1)->OnSceneDisconnection();
16748     } CALL_CATCH_EXCEPTION();
16749   }
16750
16751 }
16752
16753
16754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
16755   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16756   Dali::Actor *arg2 = 0 ;
16757
16758   arg1 = (Dali::CustomActorImpl *)jarg1;
16759   arg2 = (Dali::Actor *)jarg2;
16760   if (!arg2) {
16761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
16762     return ;
16763   }
16764   {
16765     try {
16766       (arg1)->OnChildAdd(*arg2);
16767     } CALL_CATCH_EXCEPTION();
16768   }
16769
16770 }
16771
16772
16773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
16774   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16775   Dali::Actor *arg2 = 0 ;
16776
16777   arg1 = (Dali::CustomActorImpl *)jarg1;
16778   arg2 = (Dali::Actor *)jarg2;
16779   if (!arg2) {
16780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
16781     return ;
16782   }
16783   {
16784     try {
16785       (arg1)->OnChildRemove(*arg2);
16786     } CALL_CATCH_EXCEPTION();
16787   }
16788
16789 }
16790
16791
16792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
16793   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16794   Dali::Property::Index arg2 ;
16795   Dali::Property::Value arg3 ;
16796   Dali::Property::Value *argp3 ;
16797
16798   arg1 = (Dali::CustomActorImpl *)jarg1;
16799   arg2 = (Dali::Property::Index)jarg2;
16800   argp3 = (Dali::Property::Value *)jarg3;
16801   if (!argp3) {
16802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
16803     return ;
16804   }
16805   arg3 = *argp3;
16806   {
16807     try {
16808       (arg1)->OnPropertySet(arg2,arg3);
16809     } CALL_CATCH_EXCEPTION();
16810   }
16811
16812 }
16813
16814
16815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
16816   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16817   Dali::Vector3 *arg2 = 0 ;
16818
16819   arg1 = (Dali::CustomActorImpl *)jarg1;
16820   arg2 = (Dali::Vector3 *)jarg2;
16821   if (!arg2) {
16822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16823     return ;
16824   }
16825   {
16826     try {
16827       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
16828     } CALL_CATCH_EXCEPTION();
16829   }
16830
16831 }
16832
16833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
16834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16835   Dali::Animation *arg2 = 0 ;
16836   Dali::Vector3 *arg3 = 0 ;
16837
16838   arg1 = (Dali::CustomActorImpl *)jarg1;
16839   arg2 = (Dali::Animation *)jarg2;
16840   if (!arg2) {
16841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
16842     return ;
16843   }
16844   arg3 = (Dali::Vector3 *)jarg3;
16845   if (!arg3) {
16846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16847     return ;
16848   }
16849   {
16850     try {
16851       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
16852     } CALL_CATCH_EXCEPTION();
16853   }
16854 }
16855
16856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
16857   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16858   Dali::Vector2 *arg2 = 0 ;
16859   Dali::RelayoutContainer *arg3 = 0 ;
16860
16861   arg1 = (Dali::CustomActorImpl *)jarg1;
16862   arg2 = (Dali::Vector2 *)jarg2;
16863   if (!arg2) {
16864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16865     return ;
16866   }
16867   arg3 = (Dali::RelayoutContainer *)jarg3;
16868   if (!arg3) {
16869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
16870     return ;
16871   }
16872   {
16873     try {
16874       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
16875     } CALL_CATCH_EXCEPTION();
16876   }
16877
16878 }
16879
16880
16881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
16882   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16883   Dali::ResizePolicy::Type arg2 ;
16884   Dali::Dimension::Type arg3 ;
16885
16886   arg1 = (Dali::CustomActorImpl *)jarg1;
16887   arg2 = (Dali::ResizePolicy::Type)jarg2;
16888   arg3 = (Dali::Dimension::Type)jarg3;
16889   {
16890     try {
16891       (arg1)->OnSetResizePolicy(arg2,arg3);
16892     } CALL_CATCH_EXCEPTION();
16893   }
16894
16895 }
16896
16897
16898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
16899   void * jresult ;
16900   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16901   Dali::Vector3 result;
16902
16903   arg1 = (Dali::CustomActorImpl *)jarg1;
16904   {
16905     try {
16906       result = (arg1)->GetNaturalSize();
16907     } CALL_CATCH_EXCEPTION(0);
16908   }
16909
16910   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
16911   return jresult;
16912 }
16913
16914
16915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
16916   float jresult ;
16917   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16918   Dali::Actor *arg2 = 0 ;
16919   Dali::Dimension::Type arg3 ;
16920   float result;
16921
16922   arg1 = (Dali::CustomActorImpl *)jarg1;
16923   arg2 = (Dali::Actor *)jarg2;
16924   if (!arg2) {
16925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
16926     return 0;
16927   }
16928   arg3 = (Dali::Dimension::Type)jarg3;
16929   {
16930     try {
16931       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
16932     } CALL_CATCH_EXCEPTION(0);
16933   }
16934
16935   jresult = result;
16936   return jresult;
16937 }
16938
16939
16940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
16941   float jresult ;
16942   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16943   float arg2 ;
16944   float result;
16945
16946   arg1 = (Dali::CustomActorImpl *)jarg1;
16947   arg2 = (float)jarg2;
16948   {
16949     try {
16950       result = (float)(arg1)->GetHeightForWidth(arg2);
16951     } CALL_CATCH_EXCEPTION(0);
16952   }
16953
16954   jresult = result;
16955   return jresult;
16956 }
16957
16958
16959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
16960   float jresult ;
16961   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16962   float arg2 ;
16963   float result;
16964
16965   arg1 = (Dali::CustomActorImpl *)jarg1;
16966   arg2 = (float)jarg2;
16967   {
16968     try {
16969       result = (float)(arg1)->GetWidthForHeight(arg2);
16970     } CALL_CATCH_EXCEPTION(0);
16971   }
16972
16973   jresult = result;
16974   return jresult;
16975 }
16976
16977
16978 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
16979   bool jresult ;
16980   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
16981   Dali::Dimension::Type arg2 ;
16982   bool result;
16983
16984   arg1 = (Dali::CustomActorImpl *)jarg1;
16985   arg2 = (Dali::Dimension::Type)jarg2;
16986   {
16987     try {
16988       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
16989     } CALL_CATCH_EXCEPTION(0);
16990   }
16991
16992   jresult = result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
16998   bool jresult ;
16999   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17000   bool result;
17001
17002   arg1 = (Dali::CustomActorImpl *)jarg1;
17003   {
17004     try {
17005       result = (bool)(arg1)->RelayoutDependentOnChildren();
17006     } CALL_CATCH_EXCEPTION(0);
17007   }
17008
17009   jresult = result;
17010   return jresult;
17011 }
17012
17013
17014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
17015   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17016   Dali::Dimension::Type arg2 ;
17017
17018   arg1 = (Dali::CustomActorImpl *)jarg1;
17019   arg2 = (Dali::Dimension::Type)jarg2;
17020   {
17021     try {
17022       (arg1)->OnCalculateRelayoutSize(arg2);
17023     } CALL_CATCH_EXCEPTION();
17024   }
17025
17026 }
17027
17028
17029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
17030   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17031   float arg2 ;
17032   Dali::Dimension::Type arg3 ;
17033
17034   arg1 = (Dali::CustomActorImpl *)jarg1;
17035   arg2 = (float)jarg2;
17036   arg3 = (Dali::Dimension::Type)jarg3;
17037   {
17038     try {
17039       (arg1)->OnLayoutNegotiated(arg2,arg3);
17040     } CALL_CATCH_EXCEPTION();
17041   }
17042
17043 }
17044
17045 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
17046   bool jresult ;
17047   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
17048   bool result;
17049
17050   arg1 = (Dali::CustomActorImpl *)jarg1;
17051   {
17052     try {
17053       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
17054     } CALL_CATCH_EXCEPTION(0);
17055   }
17056
17057   jresult = result;
17058   return jresult;
17059 }
17060
17061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
17062   void * jresult ;
17063   Dali::CustomActor *result = 0 ;
17064
17065   {
17066     try {
17067       result = (Dali::CustomActor *)new Dali::CustomActor();
17068     } CALL_CATCH_EXCEPTION(0);
17069   }
17070
17071   jresult = (void *)result;
17072   return jresult;
17073 }
17074
17075
17076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
17077   void * jresult ;
17078   Dali::BaseHandle arg1 ;
17079   Dali::BaseHandle *argp1 ;
17080   Dali::CustomActor result;
17081
17082   argp1 = (Dali::BaseHandle *)jarg1;
17083   if (!argp1) {
17084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17085     return 0;
17086   }
17087   arg1 = *argp1;
17088   {
17089     try {
17090       result = Dali::CustomActor::DownCast(arg1);
17091     } CALL_CATCH_EXCEPTION(0);
17092   }
17093
17094   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
17095   return jresult;
17096 }
17097
17098
17099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
17100   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17101
17102   arg1 = (Dali::CustomActor *)jarg1;
17103   {
17104     try {
17105       delete arg1;
17106     } CALL_CATCH_EXCEPTION();
17107   }
17108
17109 }
17110
17111
17112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
17113   void * jresult ;
17114   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17115   Dali::CustomActorImpl *result = 0 ;
17116
17117   arg1 = (Dali::CustomActor *)jarg1;
17118   {
17119     try {
17120       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
17121     } CALL_CATCH_EXCEPTION(0);
17122   }
17123
17124   jresult = (void *)result;
17125   return jresult;
17126 }
17127
17128
17129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
17130   void * jresult ;
17131   Dali::CustomActorImpl *arg1 = 0 ;
17132   Dali::CustomActor *result = 0 ;
17133
17134   arg1 = (Dali::CustomActorImpl *)jarg1;
17135   if (!arg1) {
17136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
17137     return 0;
17138   }
17139   {
17140     try {
17141       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
17142     } CALL_CATCH_EXCEPTION(0);
17143   }
17144
17145   jresult = (void *)result;
17146   return jresult;
17147 }
17148
17149
17150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
17151   void * jresult ;
17152   Dali::CustomActor *arg1 = 0 ;
17153   Dali::CustomActor *result = 0 ;
17154
17155   arg1 = (Dali::CustomActor *)jarg1;
17156   if (!arg1) {
17157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
17158     return 0;
17159   }
17160   {
17161     try {
17162       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
17163     } CALL_CATCH_EXCEPTION(0);
17164   }
17165
17166   jresult = (void *)result;
17167   return jresult;
17168 }
17169
17170
17171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
17172   void * jresult ;
17173   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
17174   Dali::CustomActor *arg2 = 0 ;
17175   Dali::CustomActor *result = 0 ;
17176
17177   arg1 = (Dali::CustomActor *)jarg1;
17178   arg2 = (Dali::CustomActor *)jarg2;
17179   if (!arg2) {
17180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
17181     return 0;
17182   }
17183   {
17184     try {
17185       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
17186     } CALL_CATCH_EXCEPTION(0);
17187   }
17188
17189   jresult = (void *)result;
17190   return jresult;
17191 }
17192
17193
17194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
17195   int jresult ;
17196   int result;
17197
17198   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
17199   jresult = (int)result;
17200   return jresult;
17201 }
17202
17203
17204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
17205   int jresult ;
17206   int result;
17207
17208   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
17209   jresult = (int)result;
17210   return jresult;
17211 }
17212
17213
17214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
17215   int jresult ;
17216   int result;
17217
17218   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
17219   jresult = (int)result;
17220   return jresult;
17221 }
17222
17223
17224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
17225   int jresult ;
17226   int result;
17227
17228   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
17229   jresult = (int)result;
17230   return jresult;
17231 }
17232
17233
17234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
17235   int jresult ;
17236   int result;
17237
17238   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
17239   jresult = (int)result;
17240   return jresult;
17241 }
17242
17243
17244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
17245   int jresult ;
17246   int result;
17247
17248   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
17249   jresult = (int)result;
17250   return jresult;
17251 }
17252
17253
17254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
17255   int jresult ;
17256   int result;
17257
17258   result = (int)Dali::PanGestureDetector::Property::PANNING;
17259   jresult = (int)result;
17260   return jresult;
17261 }
17262
17263
17264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
17265   void * jresult ;
17266   Dali::PanGestureDetector::Property *result = 0 ;
17267
17268   {
17269     try {
17270       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
17271     } CALL_CATCH_EXCEPTION(0);
17272   }
17273
17274   jresult = (void *)result;
17275   return jresult;
17276 }
17277
17278
17279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
17280   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
17281
17282   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
17283   {
17284     try {
17285       delete arg1;
17286     } CALL_CATCH_EXCEPTION();
17287   }
17288
17289 }
17290
17291
17292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
17293   void * jresult ;
17294   Dali::Radian *result = 0 ;
17295
17296   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
17297   jresult = (void *)result;
17298   return jresult;
17299 }
17300
17301
17302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
17303   void * jresult ;
17304   Dali::Radian *result = 0 ;
17305
17306   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
17307   jresult = (void *)result;
17308   return jresult;
17309 }
17310
17311
17312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
17313   void * jresult ;
17314   Dali::Radian *result = 0 ;
17315
17316   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
17317   jresult = (void *)result;
17318   return jresult;
17319 }
17320
17321
17322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
17323   void * jresult ;
17324   Dali::Radian *result = 0 ;
17325
17326   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
17327   jresult = (void *)result;
17328   return jresult;
17329 }
17330
17331
17332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
17333   void * jresult ;
17334   Dali::Radian *result = 0 ;
17335
17336   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
17337   jresult = (void *)result;
17338   return jresult;
17339 }
17340
17341
17342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
17343   void * jresult ;
17344   Dali::Radian *result = 0 ;
17345
17346   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
17347   jresult = (void *)result;
17348   return jresult;
17349 }
17350
17351
17352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
17353   void * jresult ;
17354   Dali::Radian *result = 0 ;
17355
17356   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
17357   jresult = (void *)result;
17358   return jresult;
17359 }
17360
17361
17362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
17363   void * jresult ;
17364   Dali::PanGestureDetector *result = 0 ;
17365
17366   {
17367     try {
17368       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
17369     } CALL_CATCH_EXCEPTION(0);
17370   }
17371
17372   jresult = (void *)result;
17373   return jresult;
17374 }
17375
17376
17377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
17378   void * jresult ;
17379   Dali::PanGestureDetector result;
17380
17381   {
17382     try {
17383       result = Dali::PanGestureDetector::New();
17384     } CALL_CATCH_EXCEPTION(0);
17385   }
17386
17387   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
17388   return jresult;
17389 }
17390
17391
17392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
17393   void * jresult ;
17394   Dali::BaseHandle arg1 ;
17395   Dali::BaseHandle *argp1 ;
17396   Dali::PanGestureDetector result;
17397
17398   argp1 = (Dali::BaseHandle *)jarg1;
17399   if (!argp1) {
17400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17401     return 0;
17402   }
17403   arg1 = *argp1;
17404   {
17405     try {
17406       result = Dali::PanGestureDetector::DownCast(arg1);
17407     } CALL_CATCH_EXCEPTION(0);
17408   }
17409
17410   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
17411   return jresult;
17412 }
17413
17414
17415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
17416   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17417
17418   arg1 = (Dali::PanGestureDetector *)jarg1;
17419   {
17420     try {
17421       delete arg1;
17422     } CALL_CATCH_EXCEPTION();
17423   }
17424
17425 }
17426
17427
17428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
17429   void * jresult ;
17430   Dali::PanGestureDetector *arg1 = 0 ;
17431   Dali::PanGestureDetector *result = 0 ;
17432
17433   arg1 = (Dali::PanGestureDetector *)jarg1;
17434   if (!arg1) {
17435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
17436     return 0;
17437   }
17438   {
17439     try {
17440       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
17441     } CALL_CATCH_EXCEPTION(0);
17442   }
17443
17444   jresult = (void *)result;
17445   return jresult;
17446 }
17447
17448
17449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
17450   void * jresult ;
17451   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17452   Dali::PanGestureDetector *arg2 = 0 ;
17453   Dali::PanGestureDetector *result = 0 ;
17454
17455   arg1 = (Dali::PanGestureDetector *)jarg1;
17456   arg2 = (Dali::PanGestureDetector *)jarg2;
17457   if (!arg2) {
17458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
17459     return 0;
17460   }
17461   {
17462     try {
17463       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
17464     } CALL_CATCH_EXCEPTION(0);
17465   }
17466
17467   jresult = (void *)result;
17468   return jresult;
17469 }
17470
17471
17472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
17473   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17474   unsigned int arg2 ;
17475
17476   arg1 = (Dali::PanGestureDetector *)jarg1;
17477   arg2 = (unsigned int)jarg2;
17478   {
17479     try {
17480       (arg1)->SetMinimumTouchesRequired(arg2);
17481     } CALL_CATCH_EXCEPTION();
17482   }
17483
17484 }
17485
17486
17487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
17488   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17489   unsigned int arg2 ;
17490
17491   arg1 = (Dali::PanGestureDetector *)jarg1;
17492   arg2 = (unsigned int)jarg2;
17493   {
17494     try {
17495       (arg1)->SetMaximumTouchesRequired(arg2);
17496     } CALL_CATCH_EXCEPTION();
17497   }
17498
17499 }
17500
17501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumMotionEventAge(void * jarg1, unsigned int jarg2) {
17502   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17503   uint32_t arg2 ;
17504
17505   arg1 = (Dali::PanGestureDetector *)jarg1;
17506   arg2 = (uint32_t)jarg2;
17507   {
17508     try {
17509       (arg1)->SetMaximumMotionEventAge(arg2);
17510     } CALL_CATCH_EXCEPTION();
17511   }
17512
17513 }
17514
17515
17516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
17517   unsigned int jresult ;
17518   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17519   unsigned int result;
17520
17521   arg1 = (Dali::PanGestureDetector *)jarg1;
17522   {
17523     try {
17524       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
17525     } CALL_CATCH_EXCEPTION(0);
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
17534   unsigned int jresult ;
17535   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17536   unsigned int result;
17537
17538   arg1 = (Dali::PanGestureDetector *)jarg1;
17539   {
17540     try {
17541       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
17542     } CALL_CATCH_EXCEPTION(0);
17543   }
17544
17545   jresult = result;
17546   return jresult;
17547 }
17548
17549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumMotionEventAge(void * jarg1) {
17550   unsigned int jresult ;
17551   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17552   uint32_t result;
17553
17554   arg1 = (Dali::PanGestureDetector *)jarg1;
17555   {
17556     try {
17557       result = (uint32_t)((Dali::PanGestureDetector const *)arg1)->GetMaximumMotionEventAge();
17558     } CALL_CATCH_EXCEPTION(0);
17559   }
17560
17561   jresult = result;
17562   return jresult;
17563 }
17564
17565
17566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
17567   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17568   Dali::Radian arg2 ;
17569   Dali::Radian arg3 ;
17570   Dali::Radian *argp2 ;
17571   Dali::Radian *argp3 ;
17572
17573   arg1 = (Dali::PanGestureDetector *)jarg1;
17574   argp2 = (Dali::Radian *)jarg2;
17575   if (!argp2) {
17576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17577     return ;
17578   }
17579   arg2 = *argp2;
17580   argp3 = (Dali::Radian *)jarg3;
17581   if (!argp3) {
17582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17583     return ;
17584   }
17585   arg3 = *argp3;
17586   {
17587     try {
17588       (arg1)->AddAngle(arg2,arg3);
17589     } CALL_CATCH_EXCEPTION();
17590   }
17591
17592 }
17593
17594
17595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
17596   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17597   Dali::Radian arg2 ;
17598   Dali::Radian *argp2 ;
17599
17600   arg1 = (Dali::PanGestureDetector *)jarg1;
17601   argp2 = (Dali::Radian *)jarg2;
17602   if (!argp2) {
17603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17604     return ;
17605   }
17606   arg2 = *argp2;
17607   {
17608     try {
17609       (arg1)->AddAngle(arg2);
17610     } CALL_CATCH_EXCEPTION();
17611   }
17612
17613 }
17614
17615
17616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
17617   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17618   Dali::Radian arg2 ;
17619   Dali::Radian arg3 ;
17620   Dali::Radian *argp2 ;
17621   Dali::Radian *argp3 ;
17622
17623   arg1 = (Dali::PanGestureDetector *)jarg1;
17624   argp2 = (Dali::Radian *)jarg2;
17625   if (!argp2) {
17626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17627     return ;
17628   }
17629   arg2 = *argp2;
17630   argp3 = (Dali::Radian *)jarg3;
17631   if (!argp3) {
17632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17633     return ;
17634   }
17635   arg3 = *argp3;
17636   {
17637     try {
17638       (arg1)->AddDirection(arg2,arg3);
17639     } CALL_CATCH_EXCEPTION();
17640   }
17641
17642 }
17643
17644
17645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
17646   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17647   Dali::Radian arg2 ;
17648   Dali::Radian *argp2 ;
17649
17650   arg1 = (Dali::PanGestureDetector *)jarg1;
17651   argp2 = (Dali::Radian *)jarg2;
17652   if (!argp2) {
17653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17654     return ;
17655   }
17656   arg2 = *argp2;
17657   {
17658     try {
17659       (arg1)->AddDirection(arg2);
17660     } CALL_CATCH_EXCEPTION();
17661   }
17662
17663 }
17664
17665
17666 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
17667   unsigned long jresult ;
17668   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17669   size_t result;
17670
17671   arg1 = (Dali::PanGestureDetector *)jarg1;
17672   {
17673     try {
17674       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
17675     } CALL_CATCH_EXCEPTION(0);
17676   }
17677
17678   jresult = (unsigned long)result;
17679   return jresult;
17680 }
17681
17682
17683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
17684   void * jresult ;
17685   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17686   size_t arg2 ;
17687   Dali::PanGestureDetector::AngleThresholdPair result;
17688
17689   arg1 = (Dali::PanGestureDetector *)jarg1;
17690   arg2 = (size_t)jarg2;
17691   {
17692     try {
17693       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
17694     } CALL_CATCH_EXCEPTION(0);
17695   }
17696
17697   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
17698   return jresult;
17699 }
17700
17701
17702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
17703   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17704
17705   arg1 = (Dali::PanGestureDetector *)jarg1;
17706   {
17707     try {
17708       (arg1)->ClearAngles();
17709     } CALL_CATCH_EXCEPTION();
17710   }
17711
17712 }
17713
17714
17715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
17716   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17717   Dali::Radian arg2 ;
17718   Dali::Radian *argp2 ;
17719
17720   arg1 = (Dali::PanGestureDetector *)jarg1;
17721   argp2 = (Dali::Radian *)jarg2;
17722   if (!argp2) {
17723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17724     return ;
17725   }
17726   arg2 = *argp2;
17727   {
17728     try {
17729       (arg1)->RemoveAngle(arg2);
17730     } CALL_CATCH_EXCEPTION();
17731   }
17732
17733 }
17734
17735
17736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
17737   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17738   Dali::Radian arg2 ;
17739   Dali::Radian *argp2 ;
17740
17741   arg1 = (Dali::PanGestureDetector *)jarg1;
17742   argp2 = (Dali::Radian *)jarg2;
17743   if (!argp2) {
17744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
17745     return ;
17746   }
17747   arg2 = *argp2;
17748   {
17749     try {
17750       (arg1)->RemoveDirection(arg2);
17751     } CALL_CATCH_EXCEPTION();
17752   }
17753
17754 }
17755
17756
17757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
17758   void * jresult ;
17759   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
17760   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
17761
17762   arg1 = (Dali::PanGestureDetector *)jarg1;
17763   {
17764     try {
17765       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
17766     } CALL_CATCH_EXCEPTION(0);
17767   }
17768
17769   jresult = (void *)result;
17770   return jresult;
17771 }
17772
17773
17774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
17775   Dali::PanGesture *arg1 = 0 ;
17776
17777   arg1 = (Dali::PanGesture *)jarg1;
17778   if (!arg1) {
17779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
17780     return ;
17781   }
17782   {
17783     try {
17784       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
17785     } CALL_CATCH_EXCEPTION();
17786   }
17787
17788 }
17789
17790
17791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
17792   void * jresult ;
17793   Dali::PanGesture *result = 0 ;
17794
17795   {
17796     try {
17797       result = (Dali::PanGesture *)new Dali::PanGesture();
17798     } CALL_CATCH_EXCEPTION(0);
17799   }
17800
17801   jresult = (void *)result;
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_New(int jarg1) {
17807   void * jresult ;
17808   Dali::GestureState arg1 ;
17809   Dali::PanGesture result;
17810
17811   arg1 = (Dali::GestureState)jarg1;
17812   {
17813     try {
17814       result = DevelPanGesture::New(arg1);
17815     } CALL_CATCH_EXCEPTION(0);
17816   }
17817
17818   jresult = new Dali::PanGesture((const Dali::PanGesture &)result);
17819   return jresult;
17820 }
17821
17822
17823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
17824   void * jresult ;
17825   Dali::PanGesture *arg1 = 0 ;
17826   Dali::PanGesture *result = 0 ;
17827
17828   arg1 = (Dali::PanGesture *)jarg1;
17829   if (!arg1) {
17830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
17831     return 0;
17832   }
17833   {
17834     try {
17835       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
17836     } CALL_CATCH_EXCEPTION(0);
17837   }
17838
17839   jresult = (void *)result;
17840   return jresult;
17841 }
17842
17843
17844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
17845   void * jresult ;
17846   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
17847   Dali::PanGesture *arg2 = 0 ;
17848   Dali::PanGesture *result = 0 ;
17849
17850   arg1 = (Dali::PanGesture *)jarg1;
17851   arg2 = (Dali::PanGesture *)jarg2;
17852   if (!arg2) {
17853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
17854     return 0;
17855   }
17856   {
17857     try {
17858       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
17859     } CALL_CATCH_EXCEPTION(0);
17860   }
17861
17862   jresult = (void *)result;
17863   return jresult;
17864 }
17865
17866
17867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
17868   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
17869
17870   arg1 = (Dali::PanGesture *)jarg1;
17871   {
17872     try {
17873       delete arg1;
17874     } CALL_CATCH_EXCEPTION();
17875   }
17876
17877 }
17878
17879
17880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
17881   void * jresult ;
17882   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
17883   Dali::Vector2 result;
17884
17885   arg1 = (Dali::PanGesture *)jarg1;
17886   {
17887     try {
17888       result = ((Dali::PanGesture const *)arg1)->GetVelocity();
17889     } catch (std::out_of_range& e) {
17890       {
17891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17892       };
17893     } catch (std::exception& e) {
17894       {
17895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17896       };
17897     } catch (Dali::DaliException e) {
17898       {
17899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17900       };
17901     } catch (...) {
17902       {
17903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17904       };
17905     }
17906   }
17907   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
17908   return jresult;
17909 }
17910
17911
17912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
17913   void * jresult ;
17914   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
17915   Dali::Vector2 result;
17916
17917   arg1 = (Dali::PanGesture *)jarg1;
17918   {
17919     try {
17920       result = ((Dali::PanGesture const *)arg1)->GetDisplacement();
17921     } catch (std::out_of_range& e) {
17922       {
17923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17924       };
17925     } catch (std::exception& e) {
17926       {
17927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17928       };
17929     } catch (Dali::DaliException e) {
17930       {
17931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17932       };
17933     } catch (...) {
17934       {
17935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17936       };
17937     }
17938   }
17939   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
17940   return jresult;
17941 }
17942
17943
17944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
17945   void * jresult ;
17946   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
17947   Dali::Vector2 result;
17948
17949   arg1 = (Dali::PanGesture *)jarg1;
17950   {
17951     try {
17952       result = ((Dali::PanGesture const *)arg1)->GetPosition();
17953     } catch (std::out_of_range& e) {
17954       {
17955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17956       };
17957     } catch (std::exception& e) {
17958       {
17959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17960       };
17961     } catch (Dali::DaliException e) {
17962       {
17963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17964       };
17965     } catch (...) {
17966       {
17967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17968       };
17969     }
17970   }
17971   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
17972   return jresult;
17973 }
17974
17975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
17976   void * jresult ;
17977   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
17978   Dali::Vector2 result;
17979
17980   arg1 = (Dali::PanGesture *)jarg1;
17981   {
17982     try {
17983       result = ((Dali::PanGesture const *)arg1)->GetScreenVelocity();
17984     } catch (std::out_of_range& e) {
17985       {
17986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17987       };
17988     } catch (std::exception& e) {
17989       {
17990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17991       };
17992     } catch (Dali::DaliException e) {
17993       {
17994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17995       };
17996     } catch (...) {
17997       {
17998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17999       };
18000     }
18001   }
18002   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18003   return jresult;
18004 }
18005
18006
18007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
18008   void * jresult ;
18009   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18010   Dali::Vector2 result;
18011
18012   arg1 = (Dali::PanGesture *)jarg1;
18013   {
18014     try {
18015       result = ((Dali::PanGesture const *)arg1)->GetScreenDisplacement();
18016     } catch (std::out_of_range& e) {
18017       {
18018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18019       };
18020     } catch (std::exception& e) {
18021       {
18022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18023       };
18024     } catch (Dali::DaliException e) {
18025       {
18026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18027       };
18028     } catch (...) {
18029       {
18030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18031       };
18032     }
18033   }
18034   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18035   return jresult;
18036 }
18037
18038
18039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
18040   void * jresult ;
18041   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18042   Dali::Vector2 result;
18043
18044   arg1 = (Dali::PanGesture *)jarg1;
18045   {
18046     try {
18047       result = ((Dali::PanGesture const *)arg1)->GetScreenPosition();
18048     } catch (std::out_of_range& e) {
18049       {
18050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18051       };
18052     } catch (std::exception& e) {
18053       {
18054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18055       };
18056     } catch (Dali::DaliException e) {
18057       {
18058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18059       };
18060     } catch (...) {
18061       {
18062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18063       };
18064     }
18065   }
18066   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18067   return jresult;
18068 }
18069
18070
18071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
18072   unsigned int jresult ;
18073   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18074   unsigned int result;
18075
18076   arg1 = (Dali::PanGesture *)jarg1;
18077   result = (unsigned int) ((arg1)->GetNumberOfTouches());
18078   jresult = result;
18079   return jresult;
18080 }
18081
18082
18083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
18084   float jresult ;
18085   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18086   float result;
18087
18088   arg1 = (Dali::PanGesture *)jarg1;
18089   {
18090     try {
18091       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
18092     } CALL_CATCH_EXCEPTION(0);
18093   }
18094
18095   jresult = result;
18096   return jresult;
18097 }
18098
18099
18100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
18101   float jresult ;
18102   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18103   float result;
18104
18105   arg1 = (Dali::PanGesture *)jarg1;
18106   {
18107     try {
18108       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
18109     } CALL_CATCH_EXCEPTION(0);
18110   }
18111
18112   jresult = result;
18113   return jresult;
18114 }
18115
18116
18117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
18118   float jresult ;
18119   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18120   float result;
18121
18122   arg1 = (Dali::PanGesture *)jarg1;
18123   {
18124     try {
18125       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
18126     } CALL_CATCH_EXCEPTION(0);
18127   }
18128
18129   jresult = result;
18130   return jresult;
18131 }
18132
18133
18134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
18135   float jresult ;
18136   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
18137   float result;
18138
18139   arg1 = (Dali::PanGesture *)jarg1;
18140   {
18141     try {
18142       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
18143     } CALL_CATCH_EXCEPTION(0);
18144   }
18145
18146   jresult = result;
18147   return jresult;
18148 }
18149
18150
18151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
18152   void * jresult ;
18153   Dali::PinchGestureDetector *result = 0 ;
18154
18155   {
18156     try {
18157       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
18158     } CALL_CATCH_EXCEPTION(0);
18159   }
18160
18161   jresult = (void *)result;
18162   return jresult;
18163 }
18164
18165
18166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
18167   void * jresult ;
18168   Dali::PinchGestureDetector result;
18169
18170   {
18171     try {
18172       result = Dali::PinchGestureDetector::New();
18173     } CALL_CATCH_EXCEPTION(0);
18174   }
18175
18176   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
18177   return jresult;
18178 }
18179
18180
18181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
18182   void * jresult ;
18183   Dali::BaseHandle arg1 ;
18184   Dali::BaseHandle *argp1 ;
18185   Dali::PinchGestureDetector result;
18186
18187   argp1 = (Dali::BaseHandle *)jarg1;
18188   if (!argp1) {
18189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18190     return 0;
18191   }
18192   arg1 = *argp1;
18193   {
18194     try {
18195       result = Dali::PinchGestureDetector::DownCast(arg1);
18196     } CALL_CATCH_EXCEPTION(0);
18197   }
18198
18199   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
18200   return jresult;
18201 }
18202
18203
18204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
18205   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18206
18207   arg1 = (Dali::PinchGestureDetector *)jarg1;
18208   {
18209     try {
18210       delete arg1;
18211     } CALL_CATCH_EXCEPTION();
18212   }
18213
18214 }
18215
18216
18217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
18218   void * jresult ;
18219   Dali::PinchGestureDetector *arg1 = 0 ;
18220   Dali::PinchGestureDetector *result = 0 ;
18221
18222   arg1 = (Dali::PinchGestureDetector *)jarg1;
18223   if (!arg1) {
18224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
18225     return 0;
18226   }
18227   {
18228     try {
18229       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
18230     } CALL_CATCH_EXCEPTION(0);
18231   }
18232
18233   jresult = (void *)result;
18234   return jresult;
18235 }
18236
18237
18238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
18239   void * jresult ;
18240   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18241   Dali::PinchGestureDetector *arg2 = 0 ;
18242   Dali::PinchGestureDetector *result = 0 ;
18243
18244   arg1 = (Dali::PinchGestureDetector *)jarg1;
18245   arg2 = (Dali::PinchGestureDetector *)jarg2;
18246   if (!arg2) {
18247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
18248     return 0;
18249   }
18250   {
18251     try {
18252       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
18253     } CALL_CATCH_EXCEPTION(0);
18254   }
18255
18256   jresult = (void *)result;
18257   return jresult;
18258 }
18259
18260
18261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
18262   void * jresult ;
18263   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
18264   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
18265
18266   arg1 = (Dali::PinchGestureDetector *)jarg1;
18267   {
18268     try {
18269       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
18270     } CALL_CATCH_EXCEPTION(0);
18271   }
18272
18273   jresult = (void *)result;
18274   return jresult;
18275 }
18276
18277
18278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0() {
18279   void * jresult ;
18280   Dali::PinchGesture *result = 0 ;
18281
18282   {
18283     try {
18284       result = (Dali::PinchGesture *)new Dali::PinchGesture();
18285     } CALL_CATCH_EXCEPTION(0);
18286   }
18287
18288   jresult = (void *)result;
18289   return jresult;
18290 }
18291
18292
18293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_New(int jarg1) {
18294   void * jresult ;
18295   Dali::GestureState arg1 ;
18296   Dali::PinchGesture result;
18297
18298   arg1 = (Dali::GestureState)jarg1;
18299   {
18300     try {
18301       result = DevelPinchGesture::New(arg1);
18302     } CALL_CATCH_EXCEPTION(0);
18303   }
18304
18305   jresult = new Dali::PinchGesture((const Dali::PinchGesture &)result);
18306   return jresult;
18307 }
18308
18309
18310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
18311   void * jresult ;
18312   Dali::PinchGesture *arg1 = 0 ;
18313   Dali::PinchGesture *result = 0 ;
18314
18315   arg1 = (Dali::PinchGesture *)jarg1;
18316   if (!arg1) {
18317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
18318     return 0;
18319   }
18320   {
18321     try {
18322       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
18323     } CALL_CATCH_EXCEPTION(0);
18324   }
18325
18326   jresult = (void *)result;
18327   return jresult;
18328 }
18329
18330
18331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
18332   void * jresult ;
18333   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18334   Dali::PinchGesture *arg2 = 0 ;
18335   Dali::PinchGesture *result = 0 ;
18336
18337   arg1 = (Dali::PinchGesture *)jarg1;
18338   arg2 = (Dali::PinchGesture *)jarg2;
18339   if (!arg2) {
18340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
18341     return 0;
18342   }
18343   {
18344     try {
18345       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
18346     } CALL_CATCH_EXCEPTION(0);
18347   }
18348
18349   jresult = (void *)result;
18350   return jresult;
18351 }
18352
18353
18354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
18355   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18356
18357   arg1 = (Dali::PinchGesture *)jarg1;
18358   {
18359     try {
18360       delete arg1;
18361     } CALL_CATCH_EXCEPTION();
18362   }
18363
18364 }
18365
18366
18367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
18368   float jresult ;
18369   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18370   float result;
18371
18372   arg1 = (Dali::PinchGesture *)jarg1;
18373   result = (float) ((arg1)->GetScale());
18374   jresult = result;
18375   return jresult;
18376 }
18377
18378
18379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
18380   float jresult ;
18381   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18382   float result;
18383
18384   arg1 = (Dali::PinchGesture *)jarg1;
18385   result = (float) ((arg1)->GetSpeed());
18386   jresult = result;
18387   return jresult;
18388 }
18389
18390
18391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
18392   void * jresult ;
18393   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18394   Dali::Vector2 result;
18395
18396   arg1 = (Dali::PinchGesture *)jarg1;
18397   {
18398     try {
18399       result = ((Dali::PinchGesture const *)arg1)->GetScreenCenterPoint();
18400     } catch (std::out_of_range& e) {
18401       {
18402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18403       };
18404     } catch (std::exception& e) {
18405       {
18406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18407       };
18408     } catch (Dali::DaliException e) {
18409       {
18410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18411       };
18412     } catch (...) {
18413       {
18414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18415       };
18416     }
18417   }
18418   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18419   return jresult;
18420 }
18421
18422
18423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
18424   void * jresult ;
18425   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
18426   Dali::Vector2 result;
18427
18428   arg1 = (Dali::PinchGesture *)jarg1;
18429   {
18430     try {
18431       result = ((Dali::PinchGesture const *)arg1)->GetLocalCenterPoint();
18432     } catch (std::out_of_range& e) {
18433       {
18434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18435       };
18436     } catch (std::exception& e) {
18437       {
18438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18439       };
18440     } catch (Dali::DaliException e) {
18441       {
18442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18443       };
18444     } catch (...) {
18445       {
18446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18447       };
18448     }
18449   }
18450   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18451   return jresult;
18452 }
18453
18454
18455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
18456   void * jresult ;
18457   Dali::TapGestureDetector *result = 0 ;
18458
18459   {
18460     try {
18461       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
18462     } CALL_CATCH_EXCEPTION(0);
18463   }
18464
18465   jresult = (void *)result;
18466   return jresult;
18467 }
18468
18469
18470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
18471   void * jresult ;
18472   Dali::TapGestureDetector result;
18473
18474   {
18475     try {
18476       result = Dali::TapGestureDetector::New();
18477     } CALL_CATCH_EXCEPTION(0);
18478   }
18479
18480   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18481   return jresult;
18482 }
18483
18484
18485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
18486   void * jresult ;
18487   unsigned int arg1 ;
18488   Dali::TapGestureDetector result;
18489
18490   arg1 = (unsigned int)jarg1;
18491   {
18492     try {
18493       result = Dali::TapGestureDetector::New(arg1);
18494     } CALL_CATCH_EXCEPTION(0);
18495   }
18496
18497   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18498   return jresult;
18499 }
18500
18501
18502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
18503   void * jresult ;
18504   Dali::BaseHandle arg1 ;
18505   Dali::BaseHandle *argp1 ;
18506   Dali::TapGestureDetector result;
18507
18508   argp1 = (Dali::BaseHandle *)jarg1;
18509   if (!argp1) {
18510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
18511     return 0;
18512   }
18513   arg1 = *argp1;
18514   {
18515     try {
18516       result = Dali::TapGestureDetector::DownCast(arg1);
18517     } CALL_CATCH_EXCEPTION(0);
18518   }
18519
18520   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
18521   return jresult;
18522 }
18523
18524
18525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
18526   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18527
18528   arg1 = (Dali::TapGestureDetector *)jarg1;
18529   {
18530     try {
18531       delete arg1;
18532     } CALL_CATCH_EXCEPTION();
18533   }
18534
18535 }
18536
18537
18538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
18539   void * jresult ;
18540   Dali::TapGestureDetector *arg1 = 0 ;
18541   Dali::TapGestureDetector *result = 0 ;
18542
18543   arg1 = (Dali::TapGestureDetector *)jarg1;
18544   if (!arg1) {
18545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18546     return 0;
18547   }
18548   {
18549     try {
18550       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
18551     } CALL_CATCH_EXCEPTION(0);
18552   }
18553
18554   jresult = (void *)result;
18555   return jresult;
18556 }
18557
18558
18559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
18560   void * jresult ;
18561   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18562   Dali::TapGestureDetector *arg2 = 0 ;
18563   Dali::TapGestureDetector *result = 0 ;
18564
18565   arg1 = (Dali::TapGestureDetector *)jarg1;
18566   arg2 = (Dali::TapGestureDetector *)jarg2;
18567   if (!arg2) {
18568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18569     return 0;
18570   }
18571   {
18572     try {
18573       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
18574     } CALL_CATCH_EXCEPTION(0);
18575   }
18576
18577   jresult = (void *)result;
18578   return jresult;
18579 }
18580
18581
18582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
18583   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18584   unsigned int arg2 ;
18585
18586   arg1 = (Dali::TapGestureDetector *)jarg1;
18587   arg2 = (unsigned int)jarg2;
18588   {
18589     try {
18590       (arg1)->SetMinimumTapsRequired(arg2);
18591     } CALL_CATCH_EXCEPTION();
18592   }
18593
18594 }
18595
18596
18597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
18598   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18599   unsigned int arg2 ;
18600
18601   arg1 = (Dali::TapGestureDetector *)jarg1;
18602   arg2 = (unsigned int)jarg2;
18603   {
18604     try {
18605       (arg1)->SetMaximumTapsRequired(arg2);
18606     } CALL_CATCH_EXCEPTION();
18607   }
18608
18609 }
18610
18611
18612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
18613   unsigned int jresult ;
18614   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18615   unsigned int result;
18616
18617   arg1 = (Dali::TapGestureDetector *)jarg1;
18618   {
18619     try {
18620       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
18621     } CALL_CATCH_EXCEPTION(0);
18622   }
18623
18624   jresult = result;
18625   return jresult;
18626 }
18627
18628
18629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
18630   unsigned int jresult ;
18631   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18632   unsigned int result;
18633
18634   arg1 = (Dali::TapGestureDetector *)jarg1;
18635   {
18636     try {
18637       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
18638     } CALL_CATCH_EXCEPTION(0);
18639   }
18640
18641   jresult = result;
18642   return jresult;
18643 }
18644
18645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_ReceiveAllTapEvents(void * tapGestureDetector, bool isReceive) {
18646   Dali::TapGestureDetector *detector = (Dali::TapGestureDetector *) 0 ;
18647
18648   detector = (Dali::TapGestureDetector *)tapGestureDetector;
18649   if (!detector) {
18650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
18651     return;
18652   }
18653   {
18654     try {
18655       (detector)->ReceiveAllTapEvents(isReceive);
18656     } CALL_CATCH_EXCEPTION();
18657   }
18658
18659 }
18660
18661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
18662   void * jresult ;
18663   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
18664   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
18665
18666   arg1 = (Dali::TapGestureDetector *)jarg1;
18667   {
18668     try {
18669       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
18670     } CALL_CATCH_EXCEPTION(0);
18671   }
18672
18673   jresult = (void *)result;
18674   return jresult;
18675 }
18676
18677
18678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
18679   void * jresult ;
18680   Dali::TapGesture *result = 0 ;
18681
18682   {
18683     try {
18684       result = (Dali::TapGesture *)new Dali::TapGesture();
18685     } CALL_CATCH_EXCEPTION(0);
18686   }
18687
18688   jresult = (void *)result;
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_New(int jarg1) {
18694   void * jresult ;
18695   Dali::GestureState arg1 ;
18696   Dali::TapGesture result;
18697
18698   arg1 = (Dali::GestureState)jarg1;
18699   {
18700     try {
18701       result = DevelTapGesture::New(arg1);
18702     } CALL_CATCH_EXCEPTION(0);
18703   }
18704
18705   jresult = new Dali::TapGesture((const Dali::TapGesture &)result);
18706   return jresult;
18707 }
18708
18709
18710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
18711   void * jresult ;
18712   Dali::TapGesture *arg1 = 0 ;
18713   Dali::TapGesture *result = 0 ;
18714
18715   arg1 = (Dali::TapGesture *)jarg1;
18716   if (!arg1) {
18717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
18718     return 0;
18719   }
18720   {
18721     try {
18722       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
18723     } CALL_CATCH_EXCEPTION(0);
18724   }
18725
18726   jresult = (void *)result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
18732   void * jresult ;
18733   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
18734   Dali::TapGesture *arg2 = 0 ;
18735   Dali::TapGesture *result = 0 ;
18736
18737   arg1 = (Dali::TapGesture *)jarg1;
18738   arg2 = (Dali::TapGesture *)jarg2;
18739   if (!arg2) {
18740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
18741     return 0;
18742   }
18743   {
18744     try {
18745       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
18746     } CALL_CATCH_EXCEPTION(0);
18747   }
18748
18749   jresult = (void *)result;
18750   return jresult;
18751 }
18752
18753
18754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
18755   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
18756
18757   arg1 = (Dali::TapGesture *)jarg1;
18758   {
18759     try {
18760       delete arg1;
18761     } CALL_CATCH_EXCEPTION();
18762   }
18763
18764 }
18765
18766
18767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
18768   unsigned int jresult ;
18769   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
18770   unsigned int result;
18771
18772   arg1 = (Dali::TapGesture *)jarg1;
18773   result = (unsigned int) ((arg1)->GetNumberOfTaps());
18774   jresult = result;
18775   return jresult;
18776 }
18777
18778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
18779   unsigned int jresult ;
18780   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
18781   unsigned int result;
18782
18783   arg1 = (Dali::TapGesture *)jarg1;
18784   result = (unsigned int) ((arg1)->GetNumberOfTouches());
18785   jresult = result;
18786   return jresult;
18787 }
18788
18789
18790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
18791   void * jresult ;
18792   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
18793   Dali::Vector2 result;
18794
18795   arg1 = (Dali::TapGesture *)jarg1;
18796   {
18797     try {
18798       result = ((Dali::TapGesture const *)arg1)->GetScreenPoint();
18799     } catch (std::out_of_range& e) {
18800       {
18801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18802       };
18803     } catch (std::exception& e) {
18804       {
18805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18806       };
18807     } catch (Dali::DaliException e) {
18808       {
18809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18810       };
18811     } catch (...) {
18812       {
18813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18814       };
18815     }
18816   }
18817   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18818   return jresult;
18819 }
18820
18821
18822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
18823   void * jresult ;
18824   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
18825   Dali::Vector2 result;
18826
18827   arg1 = (Dali::TapGesture *)jarg1;
18828   {
18829     try {
18830       result = ((Dali::TapGesture const *)arg1)->GetLocalPoint();
18831     } catch (std::out_of_range& e) {
18832       {
18833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18834       };
18835     } catch (std::exception& e) {
18836       {
18837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18838       };
18839     } catch (Dali::DaliException e) {
18840       {
18841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18842       };
18843     } catch (...) {
18844       {
18845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18846       };
18847     }
18848   }
18849   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
18850   return jresult;
18851 }
18852
18853
18854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
18855   void * jresult ;
18856   Dali::AlphaFunction *result = 0 ;
18857
18858   {
18859     try {
18860       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
18861     } CALL_CATCH_EXCEPTION(0);
18862   }
18863
18864   jresult = (void *)result;
18865   return jresult;
18866 }
18867
18868
18869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
18870   void * jresult ;
18871   Dali::AlphaFunction::BuiltinFunction arg1 ;
18872   Dali::AlphaFunction *result = 0 ;
18873
18874   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
18875   {
18876     try {
18877       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
18878     } CALL_CATCH_EXCEPTION(0);
18879   }
18880
18881   jresult = (void *)result;
18882   return jresult;
18883 }
18884
18885
18886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
18887   void * jresult ;
18888   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
18889   Dali::AlphaFunction *result = 0 ;
18890
18891   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
18892   {
18893     try {
18894       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
18895     } CALL_CATCH_EXCEPTION(0);
18896   }
18897
18898   jresult = (void *)result;
18899   return jresult;
18900 }
18901
18902
18903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
18904   void * jresult ;
18905   Dali::Vector2 *arg1 = 0 ;
18906   Dali::Vector2 *arg2 = 0 ;
18907   Dali::AlphaFunction *result = 0 ;
18908
18909   arg1 = (Dali::Vector2 *)jarg1;
18910   if (!arg1) {
18911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
18912     return 0;
18913   }
18914   arg2 = (Dali::Vector2 *)jarg2;
18915   if (!arg2) {
18916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
18917     return 0;
18918   }
18919   {
18920     try {
18921       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
18922     } CALL_CATCH_EXCEPTION(0);
18923   }
18924
18925   jresult = (void *)result;
18926   return jresult;
18927 }
18928
18929
18930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
18931   void * jresult ;
18932   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
18933   Dali::Vector4 result;
18934
18935   arg1 = (Dali::AlphaFunction *)jarg1;
18936   {
18937     try {
18938       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
18939     } CALL_CATCH_EXCEPTION(0);
18940   }
18941
18942   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
18943   return jresult;
18944 }
18945
18946
18947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
18948   void * jresult ;
18949   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
18950   Dali::AlphaFunctionPrototype result;
18951
18952   arg1 = (Dali::AlphaFunction *)jarg1;
18953   {
18954     try {
18955       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
18956     } CALL_CATCH_EXCEPTION(0);
18957   }
18958
18959   jresult = (void *)result;
18960   return jresult;
18961 }
18962
18963
18964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
18965   int jresult ;
18966   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
18967   Dali::AlphaFunction::BuiltinFunction result;
18968
18969   arg1 = (Dali::AlphaFunction *)jarg1;
18970   {
18971     try {
18972       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
18973     } CALL_CATCH_EXCEPTION(0);
18974   }
18975
18976   jresult = (int)result;
18977   return jresult;
18978 }
18979
18980
18981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
18982   int jresult ;
18983   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
18984   Dali::AlphaFunction::Mode result;
18985
18986   arg1 = (Dali::AlphaFunction *)jarg1;
18987   {
18988     try {
18989       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
18990     } CALL_CATCH_EXCEPTION(0);
18991   }
18992
18993   jresult = (int)result;
18994   return jresult;
18995 }
18996
18997
18998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
18999   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
19000
19001   arg1 = (Dali::AlphaFunction *)jarg1;
19002   {
19003     try {
19004       delete arg1;
19005     } CALL_CATCH_EXCEPTION();
19006   }
19007
19008 }
19009
19010
19011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
19012   void * jresult ;
19013   Dali::KeyFrames result;
19014
19015   {
19016     try {
19017       result = Dali::KeyFrames::New();
19018     } CALL_CATCH_EXCEPTION(0);
19019   }
19020
19021   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
19022   return jresult;
19023 }
19024
19025
19026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
19027   void * jresult ;
19028   Dali::BaseHandle arg1 ;
19029   Dali::BaseHandle *argp1 ;
19030   Dali::KeyFrames result;
19031
19032   argp1 = (Dali::BaseHandle *)jarg1;
19033   if (!argp1) {
19034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19035     return 0;
19036   }
19037   arg1 = *argp1;
19038   {
19039     try {
19040       result = Dali::KeyFrames::DownCast(arg1);
19041     } CALL_CATCH_EXCEPTION(0);
19042   }
19043
19044   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
19045   return jresult;
19046 }
19047
19048
19049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
19050   void * jresult ;
19051   Dali::KeyFrames *result = 0 ;
19052
19053   {
19054     try {
19055       result = (Dali::KeyFrames *)new Dali::KeyFrames();
19056     } CALL_CATCH_EXCEPTION(0);
19057   }
19058
19059   jresult = (void *)result;
19060   return jresult;
19061 }
19062
19063
19064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
19065   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19066
19067   arg1 = (Dali::KeyFrames *)jarg1;
19068   {
19069     try {
19070       delete arg1;
19071     } CALL_CATCH_EXCEPTION();
19072   }
19073
19074 }
19075
19076
19077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
19078   void * jresult ;
19079   Dali::KeyFrames *arg1 = 0 ;
19080   Dali::KeyFrames *result = 0 ;
19081
19082   arg1 = (Dali::KeyFrames *)jarg1;
19083   if (!arg1) {
19084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
19085     return 0;
19086   }
19087   {
19088     try {
19089       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
19090     } CALL_CATCH_EXCEPTION(0);
19091   }
19092
19093   jresult = (void *)result;
19094   return jresult;
19095 }
19096
19097
19098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
19099   void * jresult ;
19100   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19101   Dali::KeyFrames *arg2 = 0 ;
19102   Dali::KeyFrames *result = 0 ;
19103
19104   arg1 = (Dali::KeyFrames *)jarg1;
19105   arg2 = (Dali::KeyFrames *)jarg2;
19106   if (!arg2) {
19107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
19108     return 0;
19109   }
19110   {
19111     try {
19112       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
19113     } CALL_CATCH_EXCEPTION(0);
19114   }
19115
19116   jresult = (void *)result;
19117   return jresult;
19118 }
19119
19120
19121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
19122   int jresult ;
19123   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19124   Dali::Property::Type result;
19125
19126   arg1 = (Dali::KeyFrames *)jarg1;
19127   {
19128     try {
19129       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
19130     } CALL_CATCH_EXCEPTION(0);
19131   }
19132
19133   jresult = (int)result;
19134   return jresult;
19135 }
19136
19137
19138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
19139   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19140   float arg2 ;
19141   Dali::Property::Value arg3 ;
19142   Dali::Property::Value *argp3 ;
19143
19144   arg1 = (Dali::KeyFrames *)jarg1;
19145   arg2 = (float)jarg2;
19146   argp3 = (Dali::Property::Value *)jarg3;
19147   if (!argp3) {
19148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19149     return ;
19150   }
19151   arg3 = *argp3;
19152   {
19153     try {
19154       (arg1)->Add(arg2,arg3);
19155     } CALL_CATCH_EXCEPTION();
19156   }
19157
19158 }
19159
19160
19161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
19162   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
19163   float arg2 ;
19164   Dali::Property::Value arg3 ;
19165   Dali::AlphaFunction arg4 ;
19166   Dali::Property::Value *argp3 ;
19167   Dali::AlphaFunction *argp4 ;
19168
19169   arg1 = (Dali::KeyFrames *)jarg1;
19170   arg2 = (float)jarg2;
19171   argp3 = (Dali::Property::Value *)jarg3;
19172   if (!argp3) {
19173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19174     return ;
19175   }
19176   arg3 = *argp3;
19177   argp4 = (Dali::AlphaFunction *)jarg4;
19178   if (!argp4) {
19179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
19180     return ;
19181   }
19182   arg4 = *argp4;
19183   {
19184     try {
19185       (arg1)->Add(arg2,arg3,arg4);
19186     } CALL_CATCH_EXCEPTION();
19187   }
19188
19189 }
19190
19191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrameCount(void* keyFrames)
19192 {
19193   unsigned int jresult;
19194   {
19195     try {
19196       jresult = Dali::DevelKeyFrames::GetKeyFrameCount(*((Dali::KeyFrames*)keyFrames));
19197     } CALL_CATCH_EXCEPTION(0);
19198   }
19199   return jresult;
19200 }
19201
19202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_GetKeyFrame(void* keyFrames, unsigned int index, float* time, void* value)
19203 {
19204   if (!value) {
19205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19206     return ;
19207   }
19208   try {
19209     Dali::DevelKeyFrames::GetKeyFrame(*((Dali::KeyFrames*)keyFrames), (size_t)index, *time, *((Property::Value*)value));
19210   } CALL_CATCH_EXCEPTION();
19211 }
19212
19213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_SetKeyFrameValue(void* keyFrames, unsigned int index, void* value)
19214 {
19215   if (!value) {
19216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
19217     return ;
19218   }
19219   try {
19220     Dali::DevelKeyFrames::SetKeyFrameValue(*((Dali::KeyFrames*)keyFrames), (size_t)index, *((const Property::Value*)value));
19221   } CALL_CATCH_EXCEPTION();
19222 }
19223
19224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
19225   int jresult ;
19226   int result;
19227
19228   result = (int)Dali::Path::Property::POINTS;
19229   jresult = (int)result;
19230   return jresult;
19231 }
19232
19233
19234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
19235   int jresult ;
19236   int result;
19237
19238   result = (int)Dali::Path::Property::CONTROL_POINTS;
19239   jresult = (int)result;
19240   return jresult;
19241 }
19242
19243
19244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
19245   void * jresult ;
19246   Dali::Path::Property *result = 0 ;
19247
19248   {
19249     try {
19250       result = (Dali::Path::Property *)new Dali::Path::Property();
19251     } CALL_CATCH_EXCEPTION(0);
19252   }
19253
19254   jresult = (void *)result;
19255   return jresult;
19256 }
19257
19258
19259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
19260   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
19261
19262   arg1 = (Dali::Path::Property *)jarg1;
19263   {
19264     try {
19265       delete arg1;
19266     } CALL_CATCH_EXCEPTION();
19267   }
19268
19269 }
19270
19271
19272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
19273   void * jresult ;
19274   Dali::Path result;
19275
19276   {
19277     try {
19278       result = Dali::Path::New();
19279     } CALL_CATCH_EXCEPTION(0);
19280   }
19281
19282   jresult = new Dali::Path((const Dali::Path &)result);
19283   return jresult;
19284 }
19285
19286
19287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
19288   void * jresult ;
19289   Dali::BaseHandle arg1 ;
19290   Dali::BaseHandle *argp1 ;
19291   Dali::Path result;
19292
19293   argp1 = (Dali::BaseHandle *)jarg1;
19294   if (!argp1) {
19295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19296     return 0;
19297   }
19298   arg1 = *argp1;
19299   {
19300     try {
19301       result = Dali::Path::DownCast(arg1);
19302     } CALL_CATCH_EXCEPTION(0);
19303   }
19304
19305   jresult = new Dali::Path((const Dali::Path &)result);
19306   return jresult;
19307 }
19308
19309
19310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
19311   void * jresult ;
19312   Dali::Path *result = 0 ;
19313
19314   {
19315     try {
19316       result = (Dali::Path *)new Dali::Path();
19317     } CALL_CATCH_EXCEPTION(0);
19318   }
19319
19320   jresult = (void *)result;
19321   return jresult;
19322 }
19323
19324
19325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
19326   Dali::Path *arg1 = (Dali::Path *) 0 ;
19327
19328   arg1 = (Dali::Path *)jarg1;
19329   {
19330     try {
19331       delete arg1;
19332     } CALL_CATCH_EXCEPTION();
19333   }
19334
19335 }
19336
19337
19338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
19339   void * jresult ;
19340   Dali::Path *arg1 = 0 ;
19341   Dali::Path *result = 0 ;
19342
19343   arg1 = (Dali::Path *)jarg1;
19344   if (!arg1) {
19345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
19346     return 0;
19347   }
19348   {
19349     try {
19350       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
19351     } CALL_CATCH_EXCEPTION(0);
19352   }
19353
19354   jresult = (void *)result;
19355   return jresult;
19356 }
19357
19358
19359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
19360   void * jresult ;
19361   Dali::Path *arg1 = (Dali::Path *) 0 ;
19362   Dali::Path *arg2 = 0 ;
19363   Dali::Path *result = 0 ;
19364
19365   arg1 = (Dali::Path *)jarg1;
19366   arg2 = (Dali::Path *)jarg2;
19367   if (!arg2) {
19368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
19369     return 0;
19370   }
19371   {
19372     try {
19373       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
19374     } CALL_CATCH_EXCEPTION(0);
19375   }
19376
19377   jresult = (void *)result;
19378   return jresult;
19379 }
19380
19381
19382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
19383   Dali::Path *arg1 = (Dali::Path *) 0 ;
19384   Dali::Vector3 *arg2 = 0 ;
19385
19386   arg1 = (Dali::Path *)jarg1;
19387   arg2 = (Dali::Vector3 *)jarg2;
19388   if (!arg2) {
19389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19390     return ;
19391   }
19392   {
19393     try {
19394       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
19395     } CALL_CATCH_EXCEPTION();
19396   }
19397
19398 }
19399
19400
19401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
19402   Dali::Path *arg1 = (Dali::Path *) 0 ;
19403   Dali::Vector3 *arg2 = 0 ;
19404
19405   arg1 = (Dali::Path *)jarg1;
19406   arg2 = (Dali::Vector3 *)jarg2;
19407   if (!arg2) {
19408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
19409     return ;
19410   }
19411   {
19412     try {
19413       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
19414     } CALL_CATCH_EXCEPTION();
19415   }
19416
19417 }
19418
19419
19420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
19421   Dali::Path *arg1 = (Dali::Path *) 0 ;
19422   float arg2 ;
19423
19424   arg1 = (Dali::Path *)jarg1;
19425   arg2 = (float)jarg2;
19426   {
19427     try {
19428       (arg1)->GenerateControlPoints(arg2);
19429     } CALL_CATCH_EXCEPTION();
19430   }
19431
19432 }
19433
19434
19435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
19436   Dali::Path *arg1 = (Dali::Path *) 0 ;
19437   float arg2 ;
19438   Dali::Vector3 *arg3 = 0 ;
19439   Dali::Vector3 *arg4 = 0 ;
19440
19441   arg1 = (Dali::Path *)jarg1;
19442   arg2 = (float)jarg2;
19443   arg3 = (Dali::Vector3 *)jarg3;
19444   if (!arg3) {
19445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
19446     return ;
19447   }
19448   arg4 = (Dali::Vector3 *)jarg4;
19449   if (!arg4) {
19450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
19451     return ;
19452   }
19453   {
19454     try {
19455       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
19456     } CALL_CATCH_EXCEPTION();
19457   }
19458
19459 }
19460
19461
19462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
19463   void * jresult ;
19464   Dali::Path *arg1 = (Dali::Path *) 0 ;
19465   size_t arg2 ;
19466   Dali::Vector3 *result = 0 ;
19467
19468   arg1 = (Dali::Path *)jarg1;
19469   arg2 = (size_t)jarg2;
19470   {
19471     try {
19472       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
19473     } CALL_CATCH_EXCEPTION(0);
19474   }
19475
19476   jresult = (void *)result;
19477   return jresult;
19478 }
19479
19480
19481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
19482   void * jresult ;
19483   Dali::Path *arg1 = (Dali::Path *) 0 ;
19484   size_t arg2 ;
19485   Dali::Vector3 *result = 0 ;
19486
19487   arg1 = (Dali::Path *)jarg1;
19488   arg2 = (size_t)jarg2;
19489   {
19490     try {
19491       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
19492     } CALL_CATCH_EXCEPTION(0);
19493   }
19494
19495   jresult = (void *)result;
19496   return jresult;
19497 }
19498
19499
19500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
19501   unsigned long jresult ;
19502   Dali::Path *arg1 = (Dali::Path *) 0 ;
19503   size_t result;
19504
19505   arg1 = (Dali::Path *)jarg1;
19506   {
19507     try {
19508       result = ((Dali::Path const *)arg1)->GetPointCount();
19509     } CALL_CATCH_EXCEPTION(0);
19510   }
19511
19512   jresult = (unsigned long)result;
19513   return jresult;
19514 }
19515
19516
19517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
19518   void * jresult ;
19519   float arg1 ;
19520   Dali::TimePeriod *result = 0 ;
19521
19522   arg1 = (float)jarg1;
19523   {
19524     try {
19525       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
19526     } CALL_CATCH_EXCEPTION(0);
19527   }
19528
19529   jresult = (void *)result;
19530   return jresult;
19531 }
19532
19533
19534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
19535   void * jresult ;
19536   float arg1 ;
19537   float arg2 ;
19538   Dali::TimePeriod *result = 0 ;
19539
19540   arg1 = (float)jarg1;
19541   arg2 = (float)jarg2;
19542   {
19543     try {
19544       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
19545     } CALL_CATCH_EXCEPTION(0);
19546   }
19547
19548   jresult = (void *)result;
19549   return jresult;
19550 }
19551
19552
19553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
19554   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19555
19556   arg1 = (Dali::TimePeriod *)jarg1;
19557   {
19558     try {
19559       delete arg1;
19560     } CALL_CATCH_EXCEPTION();
19561   }
19562
19563 }
19564
19565
19566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
19567   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19568   float arg2 ;
19569
19570   arg1 = (Dali::TimePeriod *)jarg1;
19571   arg2 = (float)jarg2;
19572   if (arg1) (arg1)->delaySeconds = arg2;
19573 }
19574
19575
19576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
19577   float jresult ;
19578   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19579   float result;
19580
19581   arg1 = (Dali::TimePeriod *)jarg1;
19582   result = (float) ((arg1)->delaySeconds);
19583   jresult = result;
19584   return jresult;
19585 }
19586
19587
19588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
19589   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19590   float arg2 ;
19591
19592   arg1 = (Dali::TimePeriod *)jarg1;
19593   arg2 = (float)jarg2;
19594   if (arg1) (arg1)->durationSeconds = arg2;
19595 }
19596
19597
19598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
19599   float jresult ;
19600   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
19601   float result;
19602
19603   arg1 = (Dali::TimePeriod *)jarg1;
19604   result = (float) ((arg1)->durationSeconds);
19605   jresult = result;
19606   return jresult;
19607 }
19608
19609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
19610   int jresult ;
19611   int result;
19612
19613   result = (int)Dali::LinearConstrainer::Property::VALUE;
19614   jresult = (int)result;
19615   return jresult;
19616 }
19617
19618
19619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
19620   int jresult ;
19621   int result;
19622
19623   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
19624   jresult = (int)result;
19625   return jresult;
19626 }
19627
19628
19629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
19630   void * jresult ;
19631   Dali::LinearConstrainer::Property *result = 0 ;
19632
19633   {
19634     try {
19635       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
19636     } CALL_CATCH_EXCEPTION(0);
19637   }
19638
19639   jresult = (void *)result;
19640   return jresult;
19641 }
19642
19643
19644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
19645   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
19646
19647   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
19648   {
19649     try {
19650       delete arg1;
19651     } CALL_CATCH_EXCEPTION();
19652   }
19653
19654 }
19655
19656
19657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
19658   void * jresult ;
19659   Dali::LinearConstrainer result;
19660
19661   {
19662     try {
19663       result = Dali::LinearConstrainer::New();
19664     } CALL_CATCH_EXCEPTION(0);
19665   }
19666
19667   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
19668   return jresult;
19669 }
19670
19671
19672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
19673   void * jresult ;
19674   Dali::BaseHandle arg1 ;
19675   Dali::BaseHandle *argp1 ;
19676   Dali::LinearConstrainer result;
19677
19678   argp1 = (Dali::BaseHandle *)jarg1;
19679   if (!argp1) {
19680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19681     return 0;
19682   }
19683   arg1 = *argp1;
19684   {
19685     try {
19686       result = Dali::LinearConstrainer::DownCast(arg1);
19687     } CALL_CATCH_EXCEPTION(0);
19688   }
19689
19690   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
19691   return jresult;
19692 }
19693
19694
19695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
19696   void * jresult ;
19697   Dali::LinearConstrainer *result = 0 ;
19698
19699   {
19700     try {
19701       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
19702     } CALL_CATCH_EXCEPTION(0);
19703   }
19704
19705   jresult = (void *)result;
19706   return jresult;
19707 }
19708
19709
19710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
19711   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
19712
19713   arg1 = (Dali::LinearConstrainer *)jarg1;
19714   {
19715     try {
19716       delete arg1;
19717     } CALL_CATCH_EXCEPTION();
19718   }
19719
19720 }
19721
19722
19723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
19724   void * jresult ;
19725   Dali::LinearConstrainer *arg1 = 0 ;
19726   Dali::LinearConstrainer *result = 0 ;
19727
19728   arg1 = (Dali::LinearConstrainer *)jarg1;
19729   if (!arg1) {
19730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
19731     return 0;
19732   }
19733   {
19734     try {
19735       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
19736     } CALL_CATCH_EXCEPTION(0);
19737   }
19738
19739   jresult = (void *)result;
19740   return jresult;
19741 }
19742
19743
19744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
19745   void * jresult ;
19746   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
19747   Dali::LinearConstrainer *arg2 = 0 ;
19748   Dali::LinearConstrainer *result = 0 ;
19749
19750   arg1 = (Dali::LinearConstrainer *)jarg1;
19751   arg2 = (Dali::LinearConstrainer *)jarg2;
19752   if (!arg2) {
19753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
19754     return 0;
19755   }
19756   {
19757     try {
19758       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
19759     } CALL_CATCH_EXCEPTION(0);
19760   }
19761
19762   jresult = (void *)result;
19763   return jresult;
19764 }
19765
19766
19767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
19768   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
19769   SwigValueWrapper< Dali::Property > arg2 ;
19770   SwigValueWrapper< Dali::Property > arg3 ;
19771   Dali::Vector2 *arg4 = 0 ;
19772   Dali::Vector2 *arg5 = 0 ;
19773   Dali::Property *argp2 ;
19774   Dali::Property *argp3 ;
19775
19776   arg1 = (Dali::LinearConstrainer *)jarg1;
19777   argp2 = (Dali::Property *)jarg2;
19778   if (!argp2) {
19779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
19780     return ;
19781   }
19782   arg2 = *argp2;
19783   argp3 = (Dali::Property *)jarg3;
19784   if (!argp3) {
19785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
19786     return ;
19787   }
19788   arg3 = *argp3;
19789   arg4 = (Dali::Vector2 *)jarg4;
19790   if (!arg4) {
19791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19792     return ;
19793   }
19794   arg5 = (Dali::Vector2 *)jarg5;
19795   if (!arg5) {
19796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19797     return ;
19798   }
19799   {
19800     try {
19801       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
19802     } CALL_CATCH_EXCEPTION();
19803   }
19804
19805 }
19806
19807
19808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
19809   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
19810   SwigValueWrapper< Dali::Property > arg2 ;
19811   SwigValueWrapper< Dali::Property > arg3 ;
19812   Dali::Vector2 *arg4 = 0 ;
19813   Dali::Property *argp2 ;
19814   Dali::Property *argp3 ;
19815
19816   arg1 = (Dali::LinearConstrainer *)jarg1;
19817   argp2 = (Dali::Property *)jarg2;
19818   if (!argp2) {
19819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
19820     return ;
19821   }
19822   arg2 = *argp2;
19823   argp3 = (Dali::Property *)jarg3;
19824   if (!argp3) {
19825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
19826     return ;
19827   }
19828   arg3 = *argp3;
19829   arg4 = (Dali::Vector2 *)jarg4;
19830   if (!arg4) {
19831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
19832     return ;
19833   }
19834   {
19835     try {
19836       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
19837     } CALL_CATCH_EXCEPTION();
19838   }
19839
19840 }
19841
19842
19843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
19844   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
19845   Dali::Handle *arg2 = 0 ;
19846
19847   arg1 = (Dali::LinearConstrainer *)jarg1;
19848   arg2 = (Dali::Handle *)jarg2;
19849   if (!arg2) {
19850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
19851     return ;
19852   }
19853   {
19854     try {
19855       (arg1)->Remove(*arg2);
19856     } CALL_CATCH_EXCEPTION();
19857   }
19858
19859 }
19860
19861
19862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
19863   int jresult ;
19864   int result;
19865
19866   result = (int)Dali::PathConstrainer::Property::FORWARD;
19867   jresult = (int)result;
19868   return jresult;
19869 }
19870
19871
19872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
19873   int jresult ;
19874   int result;
19875
19876   result = (int)Dali::PathConstrainer::Property::POINTS;
19877   jresult = (int)result;
19878   return jresult;
19879 }
19880
19881
19882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
19883   int jresult ;
19884   int result;
19885
19886   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
19887   jresult = (int)result;
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
19893   void * jresult ;
19894   Dali::PathConstrainer::Property *result = 0 ;
19895
19896   {
19897     try {
19898       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
19899     } CALL_CATCH_EXCEPTION(0);
19900   }
19901
19902   jresult = (void *)result;
19903   return jresult;
19904 }
19905
19906
19907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
19908   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
19909
19910   arg1 = (Dali::PathConstrainer::Property *)jarg1;
19911   {
19912     try {
19913       delete arg1;
19914     } CALL_CATCH_EXCEPTION();
19915   }
19916
19917 }
19918
19919
19920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
19921   void * jresult ;
19922   Dali::PathConstrainer result;
19923
19924   {
19925     try {
19926       result = Dali::PathConstrainer::New();
19927     } CALL_CATCH_EXCEPTION(0);
19928   }
19929
19930   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
19931   return jresult;
19932 }
19933
19934
19935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
19936   void * jresult ;
19937   Dali::BaseHandle arg1 ;
19938   Dali::BaseHandle *argp1 ;
19939   Dali::PathConstrainer result;
19940
19941   argp1 = (Dali::BaseHandle *)jarg1;
19942   if (!argp1) {
19943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19944     return 0;
19945   }
19946   arg1 = *argp1;
19947   {
19948     try {
19949       result = Dali::PathConstrainer::DownCast(arg1);
19950     } CALL_CATCH_EXCEPTION(0);
19951   }
19952
19953   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
19959   void * jresult ;
19960   Dali::PathConstrainer *result = 0 ;
19961
19962   {
19963     try {
19964       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
19965     } CALL_CATCH_EXCEPTION(0);
19966   }
19967
19968   jresult = (void *)result;
19969   return jresult;
19970 }
19971
19972
19973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
19974   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
19975
19976   arg1 = (Dali::PathConstrainer *)jarg1;
19977   {
19978     try {
19979       delete arg1;
19980     } CALL_CATCH_EXCEPTION();
19981   }
19982
19983 }
19984
19985
19986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
19987   void * jresult ;
19988   Dali::PathConstrainer *arg1 = 0 ;
19989   Dali::PathConstrainer *result = 0 ;
19990
19991   arg1 = (Dali::PathConstrainer *)jarg1;
19992   if (!arg1) {
19993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
19994     return 0;
19995   }
19996   {
19997     try {
19998       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
19999     } CALL_CATCH_EXCEPTION(0);
20000   }
20001
20002   jresult = (void *)result;
20003   return jresult;
20004 }
20005
20006
20007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
20008   void * jresult ;
20009   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20010   Dali::PathConstrainer *arg2 = 0 ;
20011   Dali::PathConstrainer *result = 0 ;
20012
20013   arg1 = (Dali::PathConstrainer *)jarg1;
20014   arg2 = (Dali::PathConstrainer *)jarg2;
20015   if (!arg2) {
20016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
20017     return 0;
20018   }
20019   {
20020     try {
20021       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
20022     } CALL_CATCH_EXCEPTION(0);
20023   }
20024
20025   jresult = (void *)result;
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
20031   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20032   SwigValueWrapper< Dali::Property > arg2 ;
20033   SwigValueWrapper< Dali::Property > arg3 ;
20034   Dali::Vector2 *arg4 = 0 ;
20035   Dali::Vector2 *arg5 = 0 ;
20036   Dali::Property *argp2 ;
20037   Dali::Property *argp3 ;
20038
20039   arg1 = (Dali::PathConstrainer *)jarg1;
20040   argp2 = (Dali::Property *)jarg2;
20041   if (!argp2) {
20042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20043     return ;
20044   }
20045   arg2 = *argp2;
20046   argp3 = (Dali::Property *)jarg3;
20047   if (!argp3) {
20048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20049     return ;
20050   }
20051   arg3 = *argp3;
20052   arg4 = (Dali::Vector2 *)jarg4;
20053   if (!arg4) {
20054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20055     return ;
20056   }
20057   arg5 = (Dali::Vector2 *)jarg5;
20058   if (!arg5) {
20059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20060     return ;
20061   }
20062   {
20063     try {
20064       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
20065     } CALL_CATCH_EXCEPTION();
20066   }
20067
20068 }
20069
20070
20071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
20072   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20073   SwigValueWrapper< Dali::Property > arg2 ;
20074   SwigValueWrapper< Dali::Property > arg3 ;
20075   Dali::Vector2 *arg4 = 0 ;
20076   Dali::Property *argp2 ;
20077   Dali::Property *argp3 ;
20078
20079   arg1 = (Dali::PathConstrainer *)jarg1;
20080   argp2 = (Dali::Property *)jarg2;
20081   if (!argp2) {
20082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20083     return ;
20084   }
20085   arg2 = *argp2;
20086   argp3 = (Dali::Property *)jarg3;
20087   if (!argp3) {
20088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
20089     return ;
20090   }
20091   arg3 = *argp3;
20092   arg4 = (Dali::Vector2 *)jarg4;
20093   if (!arg4) {
20094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
20095     return ;
20096   }
20097   {
20098     try {
20099       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
20100     } CALL_CATCH_EXCEPTION();
20101   }
20102
20103 }
20104
20105
20106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
20107   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
20108   Dali::Handle *arg2 = 0 ;
20109
20110   arg1 = (Dali::PathConstrainer *)jarg1;
20111   arg2 = (Dali::Handle *)jarg2;
20112   if (!arg2) {
20113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
20114     return ;
20115   }
20116   {
20117     try {
20118       (arg1)->Remove(*arg2);
20119     } CALL_CATCH_EXCEPTION();
20120   }
20121
20122 }
20123
20124
20125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
20126   int jresult ;
20127   Dali::FittingMode::Type result;
20128
20129   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
20130   jresult = (int)result;
20131   return jresult;
20132 }
20133
20134
20135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
20136   int jresult ;
20137   Dali::SamplingMode::Type result;
20138
20139   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
20140   jresult = (int)result;
20141   return jresult;
20142 }
20143
20144
20145 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
20146   bool jresult ;
20147   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20148   bool result;
20149
20150   arg1 = (Dali::NativeImageInterface *)jarg1;
20151   {
20152     try {
20153       result = (bool)(arg1)->CreateResource();
20154     } CALL_CATCH_EXCEPTION(0);
20155   }
20156
20157   jresult = result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
20163   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20164
20165   arg1 = (Dali::NativeImageInterface *)jarg1;
20166   {
20167     try {
20168       (arg1)->DestroyResource();
20169     } CALL_CATCH_EXCEPTION();
20170   }
20171
20172 }
20173
20174
20175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
20176   unsigned int jresult ;
20177   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20178   unsigned int result;
20179
20180   arg1 = (Dali::NativeImageInterface *)jarg1;
20181   {
20182     try {
20183       result = (unsigned int)(arg1)->TargetTexture();
20184     } CALL_CATCH_EXCEPTION(0);
20185   }
20186
20187   jresult = result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
20193   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20194
20195   arg1 = (Dali::NativeImageInterface *)jarg1;
20196   {
20197     try {
20198       (arg1)->PrepareTexture();
20199     } CALL_CATCH_EXCEPTION();
20200   }
20201
20202 }
20203
20204
20205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
20206   unsigned int jresult ;
20207   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20208   unsigned int result;
20209
20210   arg1 = (Dali::NativeImageInterface *)jarg1;
20211   {
20212     try {
20213       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
20214     } CALL_CATCH_EXCEPTION(0);
20215   }
20216
20217   jresult = result;
20218   return jresult;
20219 }
20220
20221
20222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
20223   unsigned int jresult ;
20224   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20225   unsigned int result;
20226
20227   arg1 = (Dali::NativeImageInterface *)jarg1;
20228   {
20229     try {
20230       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
20231     } CALL_CATCH_EXCEPTION(0);
20232   }
20233
20234   jresult = result;
20235   return jresult;
20236 }
20237
20238
20239 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
20240   bool jresult ;
20241   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
20242   bool result;
20243
20244   arg1 = (Dali::NativeImageInterface *)jarg1;
20245   {
20246     try {
20247       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
20248     } CALL_CATCH_EXCEPTION(0);
20249   }
20250
20251   jresult = result;
20252   return jresult;
20253 }
20254
20255 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageInterface_GenerateUrl(void* nuiHandle)
20256 {
20257   Dali::Toolkit::ImageUrl result;
20258   Dali::NativeImageInterface* nativeImage = (Dali::NativeImageInterface*)nuiHandle;
20259   void *jresult;
20260
20261   {
20262     try {
20263       result = Dali::Toolkit::Image::GenerateUrl(nativeImage);
20264     }
20265     CALL_CATCH_EXCEPTION(0);
20266   }
20267
20268   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
20274   int jresult ;
20275   int result;
20276
20277   result = (int)Dali::CameraActor::Property::TYPE;
20278   jresult = (int)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
20284   int jresult ;
20285   int result;
20286
20287   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
20288   jresult = (int)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
20294   int jresult ;
20295   int result;
20296
20297   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
20298   jresult = (int)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
20304   int jresult ;
20305   int result;
20306
20307   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
20308   jresult = (int)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
20314   int jresult ;
20315   int result;
20316
20317   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
20318   jresult = (int)result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
20324   int jresult ;
20325   int result;
20326
20327   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
20328   jresult = (int)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
20334   int jresult ;
20335   int result;
20336
20337   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
20338   jresult = (int)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
20344   int jresult ;
20345   int result;
20346
20347   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
20348   jresult = (int)result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
20354   int jresult ;
20355   int result;
20356
20357   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
20358   jresult = (int)result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
20364   int jresult ;
20365   int result;
20366
20367   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
20368   jresult = (int)result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
20374   int jresult ;
20375   int result;
20376
20377   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
20378   jresult = (int)result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
20384   int jresult ;
20385   int result;
20386
20387   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
20388   jresult = (int)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
20394   int jresult ;
20395   int result;
20396
20397   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
20398   jresult = (int)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
20404   int jresult ;
20405   int result;
20406
20407   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
20408   jresult = (int)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ORTHOGRAPHIC_SIZE_get() {
20414   int jresult ;
20415   int result;
20416
20417   result = (int)Dali::DevelCameraActor::Property::ORTHOGRAPHIC_SIZE;
20418   jresult = (int)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_DIRECTION_get() {
20424   int jresult ;
20425   int result;
20426
20427   result = (int)Dali::DevelCameraActor::Property::PROJECTION_DIRECTION;
20428   jresult = (int)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
20434   void * jresult ;
20435   Dali::CameraActor::Property *result = 0 ;
20436
20437   {
20438     try {
20439       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
20440     } CALL_CATCH_EXCEPTION(0);
20441   }
20442
20443   jresult = (void *)result;
20444   return jresult;
20445 }
20446
20447
20448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
20449   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
20450
20451   arg1 = (Dali::CameraActor::Property *)jarg1;
20452   {
20453     try {
20454       delete arg1;
20455     } CALL_CATCH_EXCEPTION();
20456   }
20457
20458 }
20459
20460
20461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
20462   void * jresult ;
20463   Dali::CameraActor *result = 0 ;
20464
20465   {
20466     try {
20467       result = (Dali::CameraActor *)new Dali::CameraActor();
20468     } CALL_CATCH_EXCEPTION(0);
20469   }
20470
20471   jresult = (void *)result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
20477   void * jresult ;
20478   Dali::CameraActor result;
20479
20480   {
20481     try {
20482       result = Dali::CameraActor::New();
20483     } CALL_CATCH_EXCEPTION(0);
20484   }
20485
20486   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20487   return jresult;
20488 }
20489
20490
20491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
20492   void * jresult ;
20493   Dali::Size *arg1 = 0 ;
20494   Dali::CameraActor result;
20495
20496   arg1 = (Dali::Size *)jarg1;
20497   if (!arg1) {
20498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
20499     return 0;
20500   }
20501   {
20502     try {
20503       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
20504     } CALL_CATCH_EXCEPTION(0);
20505   }
20506
20507   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20508   return jresult;
20509 }
20510
20511
20512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New3DCamera() {
20513   void * jresult ;
20514   Dali::CameraActor result;
20515
20516   {
20517     try {
20518       result = Dali::CameraActor::New3DCamera();
20519     } CALL_CATCH_EXCEPTION(0);
20520   }
20521
20522   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20523   return jresult;
20524 }
20525
20526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
20527   void * jresult ;
20528   Dali::BaseHandle arg1 ;
20529   Dali::BaseHandle *argp1 ;
20530   Dali::CameraActor result;
20531
20532   argp1 = (Dali::BaseHandle *)jarg1;
20533   if (!argp1) {
20534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20535     return 0;
20536   }
20537   arg1 = *argp1;
20538   {
20539     try {
20540       result = Dali::CameraActor::DownCast(arg1);
20541     } CALL_CATCH_EXCEPTION(0);
20542   }
20543
20544   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
20545   return jresult;
20546 }
20547
20548
20549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
20550   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20551
20552   arg1 = (Dali::CameraActor *)jarg1;
20553   {
20554     try {
20555       delete arg1;
20556     } CALL_CATCH_EXCEPTION();
20557   }
20558
20559 }
20560
20561
20562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
20563   void * jresult ;
20564   Dali::CameraActor *arg1 = 0 ;
20565   Dali::CameraActor *result = 0 ;
20566
20567   arg1 = (Dali::CameraActor *)jarg1;
20568   if (!arg1) {
20569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
20570     return 0;
20571   }
20572   {
20573     try {
20574       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
20575     } CALL_CATCH_EXCEPTION(0);
20576   }
20577
20578   jresult = (void *)result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
20584   void * jresult ;
20585   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20586   Dali::CameraActor *arg2 = 0 ;
20587   Dali::CameraActor *result = 0 ;
20588
20589   arg1 = (Dali::CameraActor *)jarg1;
20590   arg2 = (Dali::CameraActor *)jarg2;
20591   if (!arg2) {
20592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
20593     return 0;
20594   }
20595   {
20596     try {
20597       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
20598     } CALL_CATCH_EXCEPTION(0);
20599   }
20600
20601   jresult = (void *)result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
20607   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20608   Dali::Camera::Type arg2 ;
20609
20610   arg1 = (Dali::CameraActor *)jarg1;
20611   arg2 = (Dali::Camera::Type)jarg2;
20612   {
20613     try {
20614       (arg1)->SetType(arg2);
20615     } CALL_CATCH_EXCEPTION();
20616   }
20617
20618 }
20619
20620
20621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
20622   int jresult ;
20623   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20624   Dali::Camera::Type result;
20625
20626   arg1 = (Dali::CameraActor *)jarg1;
20627   {
20628     try {
20629       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
20630     } CALL_CATCH_EXCEPTION(0);
20631   }
20632
20633   jresult = (int)result;
20634   return jresult;
20635 }
20636
20637
20638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
20639   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20640   Dali::Camera::ProjectionMode arg2 ;
20641
20642   arg1 = (Dali::CameraActor *)jarg1;
20643   arg2 = (Dali::Camera::ProjectionMode)jarg2;
20644   {
20645     try {
20646       (arg1)->SetProjectionMode(arg2);
20647     } CALL_CATCH_EXCEPTION();
20648   }
20649
20650 }
20651
20652
20653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
20654   int jresult ;
20655   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20656   Dali::Camera::ProjectionMode result;
20657
20658   arg1 = (Dali::CameraActor *)jarg1;
20659   {
20660     try {
20661       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
20662     } CALL_CATCH_EXCEPTION(0);
20663   }
20664
20665   jresult = (int)result;
20666   return jresult;
20667 }
20668
20669
20670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
20671   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20672   float arg2 ;
20673
20674   arg1 = (Dali::CameraActor *)jarg1;
20675   arg2 = (float)jarg2;
20676   {
20677     try {
20678       (arg1)->SetFieldOfView(arg2);
20679     } CALL_CATCH_EXCEPTION();
20680   }
20681
20682 }
20683
20684
20685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
20686   float jresult ;
20687   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20688   float result;
20689
20690   arg1 = (Dali::CameraActor *)jarg1;
20691   {
20692     try {
20693       result = (float)(arg1)->GetFieldOfView();
20694     } CALL_CATCH_EXCEPTION(0);
20695   }
20696
20697   jresult = result;
20698   return jresult;
20699 }
20700
20701
20702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
20703   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20704   float arg2 ;
20705
20706   arg1 = (Dali::CameraActor *)jarg1;
20707   arg2 = (float)jarg2;
20708   {
20709     try {
20710       (arg1)->SetAspectRatio(arg2);
20711     } CALL_CATCH_EXCEPTION();
20712   }
20713
20714 }
20715
20716
20717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
20718   float jresult ;
20719   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20720   float result;
20721
20722   arg1 = (Dali::CameraActor *)jarg1;
20723   {
20724     try {
20725       result = (float)(arg1)->GetAspectRatio();
20726     } CALL_CATCH_EXCEPTION(0);
20727   }
20728
20729   jresult = result;
20730   return jresult;
20731 }
20732
20733
20734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
20735   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20736   float arg2 ;
20737
20738   arg1 = (Dali::CameraActor *)jarg1;
20739   arg2 = (float)jarg2;
20740   {
20741     try {
20742       (arg1)->SetNearClippingPlane(arg2);
20743     } CALL_CATCH_EXCEPTION();
20744   }
20745
20746 }
20747
20748
20749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
20750   float jresult ;
20751   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20752   float result;
20753
20754   arg1 = (Dali::CameraActor *)jarg1;
20755   {
20756     try {
20757       result = (float)(arg1)->GetNearClippingPlane();
20758     } CALL_CATCH_EXCEPTION(0);
20759   }
20760
20761   jresult = result;
20762   return jresult;
20763 }
20764
20765
20766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
20767   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20768   float arg2 ;
20769
20770   arg1 = (Dali::CameraActor *)jarg1;
20771   arg2 = (float)jarg2;
20772   {
20773     try {
20774       (arg1)->SetFarClippingPlane(arg2);
20775     } CALL_CATCH_EXCEPTION();
20776   }
20777
20778 }
20779
20780
20781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
20782   float jresult ;
20783   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20784   float result;
20785
20786   arg1 = (Dali::CameraActor *)jarg1;
20787   {
20788     try {
20789       result = (float)(arg1)->GetFarClippingPlane();
20790     } CALL_CATCH_EXCEPTION(0);
20791   }
20792
20793   jresult = result;
20794   return jresult;
20795 }
20796
20797
20798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
20799   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20800   Dali::Vector3 *arg2 = 0 ;
20801
20802   arg1 = (Dali::CameraActor *)jarg1;
20803   arg2 = (Dali::Vector3 *)jarg2;
20804   if (!arg2) {
20805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
20806     return ;
20807   }
20808   {
20809     try {
20810       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
20811     } CALL_CATCH_EXCEPTION();
20812   }
20813
20814 }
20815
20816
20817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
20818   void * jresult ;
20819   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20820   Dali::Vector3 result;
20821
20822   arg1 = (Dali::CameraActor *)jarg1;
20823   {
20824     try {
20825       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
20826     } CALL_CATCH_EXCEPTION(0);
20827   }
20828
20829   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
20830   return jresult;
20831 }
20832
20833
20834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, bool jarg2) {
20835   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20836   bool arg2 ;
20837
20838   arg1 = (Dali::CameraActor *)jarg1;
20839   arg2 = jarg2 ? true : false;
20840   {
20841     try {
20842       (arg1)->SetInvertYAxis(arg2);
20843     } CALL_CATCH_EXCEPTION();
20844   }
20845
20846 }
20847
20848
20849 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
20850   bool jresult ;
20851   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20852   bool result;
20853
20854   arg1 = (Dali::CameraActor *)jarg1;
20855   {
20856     try {
20857       result = (bool)(arg1)->GetInvertYAxis();
20858     } CALL_CATCH_EXCEPTION(0);
20859   }
20860
20861   jresult = result;
20862   return jresult;
20863 }
20864
20865
20866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
20867   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20868   Dali::Size *arg2 = 0 ;
20869
20870   arg1 = (Dali::CameraActor *)jarg1;
20871   arg2 = (Dali::Size *)jarg2;
20872   if (!arg2) {
20873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
20874     return ;
20875   }
20876   {
20877     try {
20878       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
20879     } CALL_CATCH_EXCEPTION();
20880   }
20881
20882 }
20883
20884
20885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
20886   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
20887   Dali::Size *arg2 = 0 ;
20888
20889   arg1 = (Dali::CameraActor *)jarg1;
20890   arg2 = (Dali::Size *)jarg2;
20891   if (!arg2) {
20892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
20893     return ;
20894   }
20895   {
20896     try {
20897       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
20898     } CALL_CATCH_EXCEPTION();
20899   }
20900
20901 }
20902
20903
20904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
20905   void * jresult ;
20906   std::pair< std::string,Dali::Property::Value > *result = 0 ;
20907
20908   {
20909     try {
20910       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
20911     } CALL_CATCH_EXCEPTION(0);
20912   }
20913
20914   jresult = (void *)result;
20915   return jresult;
20916 }
20917
20918
20919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
20920   void * jresult ;
20921   std::string arg1 ;
20922   Dali::Property::Value arg2 ;
20923   Dali::Property::Value *argp2 ;
20924   std::pair< std::string,Dali::Property::Value > *result = 0 ;
20925
20926   if (!jarg1) {
20927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20928     return 0;
20929   }
20930   (&arg1)->assign(jarg1);
20931   argp2 = (Dali::Property::Value *)jarg2;
20932   if (!argp2) {
20933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
20934     return 0;
20935   }
20936   arg2 = *argp2;
20937   {
20938     try {
20939       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
20940     } CALL_CATCH_EXCEPTION(0);
20941   }
20942
20943   jresult = (void *)result;
20944   return jresult;
20945 }
20946
20947
20948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
20949   void * jresult ;
20950   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
20951   std::pair< std::string,Dali::Property::Value > *result = 0 ;
20952
20953   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
20954   if (!arg1) {
20955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
20956     return 0;
20957   }
20958   {
20959     try {
20960       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);
20961     } CALL_CATCH_EXCEPTION(0);
20962   }
20963
20964   jresult = (void *)result;
20965   return jresult;
20966 }
20967
20968
20969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
20970   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
20971   std::string *arg2 = 0 ;
20972
20973   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
20974   if (!jarg2) {
20975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20976     return ;
20977   }
20978   std::string arg2_str(jarg2);
20979   arg2 = &arg2_str;
20980   if (arg1) (arg1)->first = *arg2;
20981
20982   //argout typemap for const std::string&
20983
20984 }
20985
20986
20987 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
20988   char * jresult ;
20989   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
20990   std::string *result = 0 ;
20991
20992   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
20993   result = (std::string *) & ((arg1)->first);
20994   jresult = SWIG_csharp_string_callback(result->c_str());
20995   return jresult;
20996 }
20997
20998
20999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
21000   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21001   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
21002
21003   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21004   arg2 = (Dali::Property::Value *)jarg2;
21005   if (arg1) (arg1)->second = *arg2;
21006 }
21007
21008
21009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
21010   void * jresult ;
21011   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21012   Dali::Property::Value *result = 0 ;
21013
21014   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21015   result = (Dali::Property::Value *)& ((arg1)->second);
21016   jresult = (void *)result;
21017   return jresult;
21018 }
21019
21020
21021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
21022   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
21023
21024   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
21025   {
21026     try {
21027       delete arg1;
21028     } CALL_CATCH_EXCEPTION();
21029   }
21030
21031 }
21032
21033
21034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
21035   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21036
21037   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21038   {
21039     try {
21040       (arg1)->clear();
21041     } CALL_CATCH_EXCEPTION();
21042   }
21043
21044 }
21045
21046
21047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
21048   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21049   Dali::TouchPoint *arg2 = 0 ;
21050
21051   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21052   arg2 = (Dali::TouchPoint *)jarg2;
21053   if (!arg2) {
21054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21055     return ;
21056   }
21057   {
21058     try {
21059       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
21060     } CALL_CATCH_EXCEPTION();
21061   }
21062
21063 }
21064
21065
21066 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
21067   unsigned long jresult ;
21068   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21069   std::vector< Dali::TouchPoint >::size_type result;
21070
21071   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21072   {
21073     try {
21074       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
21075     } CALL_CATCH_EXCEPTION(0);
21076   }
21077
21078   jresult = (unsigned long)result;
21079   return jresult;
21080 }
21081
21082
21083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
21084   unsigned long jresult ;
21085   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21086   std::vector< Dali::TouchPoint >::size_type result;
21087
21088   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21089   {
21090     try {
21091       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
21092     } CALL_CATCH_EXCEPTION(0);
21093   }
21094
21095   jresult = (unsigned long)result;
21096   return jresult;
21097 }
21098
21099
21100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
21101   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21102   std::vector< Dali::TouchPoint >::size_type arg2 ;
21103
21104   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21105   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
21106   {
21107     try {
21108       (arg1)->reserve(arg2);
21109     } CALL_CATCH_EXCEPTION();
21110   }
21111
21112 }
21113
21114
21115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
21116   void * jresult ;
21117   std::vector< Dali::TouchPoint > *result = 0 ;
21118
21119   {
21120     try {
21121       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
21122     } CALL_CATCH_EXCEPTION(0);
21123   }
21124
21125   jresult = (void *)result;
21126   return jresult;
21127 }
21128
21129
21130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
21131   void * jresult ;
21132   std::vector< Dali::TouchPoint > *arg1 = 0 ;
21133   std::vector< Dali::TouchPoint > *result = 0 ;
21134
21135   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21136   if (!arg1) {
21137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21138     return 0;
21139   }
21140   {
21141     try {
21142       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
21143     } CALL_CATCH_EXCEPTION(0);
21144   }
21145
21146   jresult = (void *)result;
21147   return jresult;
21148 }
21149
21150
21151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
21152   void * jresult ;
21153   int arg1 ;
21154   std::vector< Dali::TouchPoint > *result = 0 ;
21155
21156   arg1 = (int)jarg1;
21157   {
21158     try {
21159       try {
21160         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
21161       }
21162       catch(std::out_of_range &_e) {
21163         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21164         return 0;
21165       }
21166
21167     } CALL_CATCH_EXCEPTION(0);
21168   }
21169
21170   jresult = (void *)result;
21171   return jresult;
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
21176   void * jresult ;
21177   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21178   int arg2 ;
21179   SwigValueWrapper< Dali::TouchPoint > result;
21180
21181   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21182   arg2 = (int)jarg2;
21183   {
21184     try {
21185       try {
21186         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
21187       }
21188       catch(std::out_of_range &_e) {
21189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21190         return 0;
21191       }
21192
21193     } CALL_CATCH_EXCEPTION(0);
21194   }
21195
21196   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
21202   void * jresult ;
21203   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21204   int arg2 ;
21205   Dali::TouchPoint *result = 0 ;
21206
21207   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21208   arg2 = (int)jarg2;
21209   {
21210     try {
21211       try {
21212         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
21213       }
21214       catch(std::out_of_range &_e) {
21215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21216         return 0;
21217       }
21218
21219     } CALL_CATCH_EXCEPTION(0);
21220   }
21221
21222   jresult = (void *)result;
21223   return jresult;
21224 }
21225
21226
21227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
21228   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21229   int arg2 ;
21230   Dali::TouchPoint *arg3 = 0 ;
21231
21232   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21233   arg2 = (int)jarg2;
21234   arg3 = (Dali::TouchPoint *)jarg3;
21235   if (!arg3) {
21236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21237     return ;
21238   }
21239   {
21240     try {
21241       try {
21242         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
21243       }
21244       catch(std::out_of_range &_e) {
21245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21246         return ;
21247       }
21248
21249     } CALL_CATCH_EXCEPTION();
21250   }
21251
21252 }
21253
21254
21255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
21256   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21257   std::vector< Dali::TouchPoint > *arg2 = 0 ;
21258
21259   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21260   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
21261   if (!arg2) {
21262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21263     return ;
21264   }
21265   {
21266     try {
21267       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
21268     } CALL_CATCH_EXCEPTION();
21269   }
21270
21271 }
21272
21273
21274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
21275   void * jresult ;
21276   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21277   int arg2 ;
21278   int arg3 ;
21279   std::vector< Dali::TouchPoint > *result = 0 ;
21280
21281   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21282   arg2 = (int)jarg2;
21283   arg3 = (int)jarg3;
21284   {
21285     try {
21286       try {
21287         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
21288       }
21289       catch(std::out_of_range &_e) {
21290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21291         return 0;
21292       }
21293       catch(std::invalid_argument &_e) {
21294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21295         return 0;
21296       }
21297
21298     } CALL_CATCH_EXCEPTION(0);
21299   }
21300
21301   jresult = (void *)result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
21307   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21308   int arg2 ;
21309   Dali::TouchPoint *arg3 = 0 ;
21310
21311   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21312   arg2 = (int)jarg2;
21313   arg3 = (Dali::TouchPoint *)jarg3;
21314   if (!arg3) {
21315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21316     return ;
21317   }
21318   {
21319     try {
21320       try {
21321         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
21322       }
21323       catch(std::out_of_range &_e) {
21324         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21325         return ;
21326       }
21327
21328     } CALL_CATCH_EXCEPTION();
21329   }
21330
21331 }
21332
21333
21334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
21335   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21336   int arg2 ;
21337   std::vector< Dali::TouchPoint > *arg3 = 0 ;
21338
21339   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21340   arg2 = (int)jarg2;
21341   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
21342   if (!arg3) {
21343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21344     return ;
21345   }
21346   {
21347     try {
21348       try {
21349         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
21350       }
21351       catch(std::out_of_range &_e) {
21352         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21353         return ;
21354       }
21355
21356     } CALL_CATCH_EXCEPTION();
21357   }
21358
21359 }
21360
21361
21362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
21363   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21364   int arg2 ;
21365
21366   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21367   arg2 = (int)jarg2;
21368   {
21369     try {
21370       try {
21371         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
21372       }
21373       catch(std::out_of_range &_e) {
21374         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21375         return ;
21376       }
21377
21378     } CALL_CATCH_EXCEPTION();
21379   }
21380
21381 }
21382
21383
21384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
21385   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21386   int arg2 ;
21387   int arg3 ;
21388
21389   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21390   arg2 = (int)jarg2;
21391   arg3 = (int)jarg3;
21392   {
21393     try {
21394       try {
21395         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
21396       }
21397       catch(std::out_of_range &_e) {
21398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21399         return ;
21400       }
21401       catch(std::invalid_argument &_e) {
21402         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21403         return ;
21404       }
21405
21406     } CALL_CATCH_EXCEPTION();
21407   }
21408
21409 }
21410
21411
21412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
21413   void * jresult ;
21414   Dali::TouchPoint *arg1 = 0 ;
21415   int arg2 ;
21416   std::vector< Dali::TouchPoint > *result = 0 ;
21417
21418   arg1 = (Dali::TouchPoint *)jarg1;
21419   if (!arg1) {
21420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
21421     return 0;
21422   }
21423   arg2 = (int)jarg2;
21424   {
21425     try {
21426       try {
21427         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
21428       }
21429       catch(std::out_of_range &_e) {
21430         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21431         return 0;
21432       }
21433
21434     } CALL_CATCH_EXCEPTION(0);
21435   }
21436
21437   jresult = (void *)result;
21438   return jresult;
21439 }
21440
21441
21442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
21443   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21444
21445   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21446   {
21447     try {
21448       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
21449     } CALL_CATCH_EXCEPTION();
21450   }
21451
21452 }
21453
21454
21455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
21456   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21457   int arg2 ;
21458   int arg3 ;
21459
21460   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21461   arg2 = (int)jarg2;
21462   arg3 = (int)jarg3;
21463   {
21464     try {
21465       try {
21466         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
21467       }
21468       catch(std::out_of_range &_e) {
21469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21470         return ;
21471       }
21472       catch(std::invalid_argument &_e) {
21473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
21474         return ;
21475       }
21476
21477     } CALL_CATCH_EXCEPTION();
21478   }
21479
21480 }
21481
21482
21483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
21484   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21485   int arg2 ;
21486   std::vector< Dali::TouchPoint > *arg3 = 0 ;
21487
21488   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21489   arg2 = (int)jarg2;
21490   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
21491   if (!arg3) {
21492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
21493     return ;
21494   }
21495   {
21496     try {
21497       try {
21498         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
21499       }
21500       catch(std::out_of_range &_e) {
21501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
21502         return ;
21503       }
21504
21505     } CALL_CATCH_EXCEPTION();
21506   }
21507
21508 }
21509
21510
21511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
21512   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
21513
21514   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
21515   {
21516     try {
21517       delete arg1;
21518     } CALL_CATCH_EXCEPTION();
21519   }
21520
21521 }
21522
21523
21524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
21525   void * jresult ;
21526   Dali::Rect< int > *result = 0 ;
21527
21528   {
21529     try {
21530       result = (Dali::Rect< int > *)new Dali::Rect< int >();
21531     } CALL_CATCH_EXCEPTION(0);
21532   }
21533
21534   jresult = (void *)result;
21535   return jresult;
21536 }
21537
21538
21539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
21540   void * jresult ;
21541   int arg1 ;
21542   int arg2 ;
21543   int arg3 ;
21544   int arg4 ;
21545   Dali::Rect< int > *result = 0 ;
21546
21547   arg1 = (int)jarg1;
21548   arg2 = (int)jarg2;
21549   arg3 = (int)jarg3;
21550   arg4 = (int)jarg4;
21551   {
21552     try {
21553       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
21554     } CALL_CATCH_EXCEPTION(0);
21555   }
21556
21557   jresult = (void *)result;
21558   return jresult;
21559 }
21560
21561
21562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
21563   void * jresult ;
21564   Dali::Rect< int > *arg1 = 0 ;
21565   Dali::Rect< int > *result = 0 ;
21566
21567   arg1 = (Dali::Rect< int > *)jarg1;
21568   if (!arg1) {
21569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
21570     return 0;
21571   }
21572   {
21573     try {
21574       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
21575     } CALL_CATCH_EXCEPTION(0);
21576   }
21577
21578   jresult = (void *)result;
21579   return jresult;
21580 }
21581
21582
21583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
21584   void * jresult ;
21585   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21586   Dali::Rect< int > *arg2 = 0 ;
21587   Dali::Rect< int > *result = 0 ;
21588
21589   arg1 = (Dali::Rect< int > *)jarg1;
21590   arg2 = (Dali::Rect< int > *)jarg2;
21591   if (!arg2) {
21592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
21593     return 0;
21594   }
21595   {
21596     try {
21597       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
21598     } CALL_CATCH_EXCEPTION(0);
21599   }
21600
21601   jresult = (void *)result;
21602   return jresult;
21603 }
21604
21605
21606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
21607   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21608   int arg2 ;
21609   int arg3 ;
21610   int arg4 ;
21611   int arg5 ;
21612
21613   arg1 = (Dali::Rect< int > *)jarg1;
21614   arg2 = (int)jarg2;
21615   arg3 = (int)jarg3;
21616   arg4 = (int)jarg4;
21617   arg5 = (int)jarg5;
21618   {
21619     try {
21620       (arg1)->Set(arg2,arg3,arg4,arg5);
21621     } CALL_CATCH_EXCEPTION();
21622   }
21623
21624 }
21625
21626
21627 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
21628   bool jresult ;
21629   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21630   bool result;
21631
21632   arg1 = (Dali::Rect< int > *)jarg1;
21633   {
21634     try {
21635       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
21636     } CALL_CATCH_EXCEPTION(0);
21637   }
21638
21639   jresult = result;
21640   return jresult;
21641 }
21642
21643
21644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
21645   int jresult ;
21646   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21647   int result;
21648
21649   arg1 = (Dali::Rect< int > *)jarg1;
21650   {
21651     try {
21652       result = (int)((Dali::Rect< int > const *)arg1)->Left();
21653     } CALL_CATCH_EXCEPTION(0);
21654   }
21655
21656   jresult = result;
21657   return jresult;
21658 }
21659
21660
21661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
21662   int jresult ;
21663   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21664   int result;
21665
21666   arg1 = (Dali::Rect< int > *)jarg1;
21667   {
21668     try {
21669       result = (int)((Dali::Rect< int > const *)arg1)->Right();
21670     } CALL_CATCH_EXCEPTION(0);
21671   }
21672
21673   jresult = result;
21674   return jresult;
21675 }
21676
21677
21678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
21679   int jresult ;
21680   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21681   int result;
21682
21683   arg1 = (Dali::Rect< int > *)jarg1;
21684   {
21685     try {
21686       result = (int)((Dali::Rect< int > const *)arg1)->Top();
21687     } CALL_CATCH_EXCEPTION(0);
21688   }
21689
21690   jresult = result;
21691   return jresult;
21692 }
21693
21694
21695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
21696   int jresult ;
21697   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21698   int result;
21699
21700   arg1 = (Dali::Rect< int > *)jarg1;
21701   {
21702     try {
21703       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
21704     } CALL_CATCH_EXCEPTION(0);
21705   }
21706
21707   jresult = result;
21708   return jresult;
21709 }
21710
21711
21712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
21713   int jresult ;
21714   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21715   int result;
21716
21717   arg1 = (Dali::Rect< int > *)jarg1;
21718   {
21719     try {
21720       result = (int)((Dali::Rect< int > const *)arg1)->Area();
21721     } CALL_CATCH_EXCEPTION(0);
21722   }
21723
21724   jresult = result;
21725   return jresult;
21726 }
21727
21728
21729 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
21730   bool jresult ;
21731   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21732   Dali::Rect< int > *arg2 = 0 ;
21733   bool result;
21734
21735   arg1 = (Dali::Rect< int > *)jarg1;
21736   arg2 = (Dali::Rect< int > *)jarg2;
21737   if (!arg2) {
21738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
21739     return 0;
21740   }
21741   {
21742     try {
21743       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
21744     } CALL_CATCH_EXCEPTION(0);
21745   }
21746
21747   jresult = result;
21748   return jresult;
21749 }
21750
21751
21752 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
21753   bool jresult ;
21754   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21755   Dali::Rect< int > *arg2 = 0 ;
21756   bool result;
21757
21758   arg1 = (Dali::Rect< int > *)jarg1;
21759   arg2 = (Dali::Rect< int > *)jarg2;
21760   if (!arg2) {
21761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
21762     return 0;
21763   }
21764   {
21765     try {
21766       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
21767     } CALL_CATCH_EXCEPTION(0);
21768   }
21769
21770   jresult = result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
21776   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21777   int arg2 ;
21778
21779   arg1 = (Dali::Rect< int > *)jarg1;
21780   arg2 = (int)jarg2;
21781   if (arg1) (arg1)->x = arg2;
21782 }
21783
21784
21785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
21786   int jresult ;
21787   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21788   int result;
21789
21790   arg1 = (Dali::Rect< int > *)jarg1;
21791   result = (int) ((arg1)->x);
21792   jresult = result;
21793   return jresult;
21794 }
21795
21796
21797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
21798   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21799   int arg2 ;
21800
21801   arg1 = (Dali::Rect< int > *)jarg1;
21802   arg2 = (int)jarg2;
21803   if (arg1) (arg1)->left = arg2;
21804 }
21805
21806
21807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
21808   int jresult ;
21809   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21810   int result;
21811
21812   arg1 = (Dali::Rect< int > *)jarg1;
21813   result = (int) ((arg1)->left);
21814   jresult = result;
21815   return jresult;
21816 }
21817
21818
21819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
21820   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21821   int arg2 ;
21822
21823   arg1 = (Dali::Rect< int > *)jarg1;
21824   arg2 = (int)jarg2;
21825   if (arg1) (arg1)->y = arg2;
21826 }
21827
21828
21829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
21830   int jresult ;
21831   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21832   int result;
21833
21834   arg1 = (Dali::Rect< int > *)jarg1;
21835   result = (int) ((arg1)->y);
21836   jresult = result;
21837   return jresult;
21838 }
21839
21840
21841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
21842   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21843   int arg2 ;
21844
21845   arg1 = (Dali::Rect< int > *)jarg1;
21846   arg2 = (int)jarg2;
21847   if (arg1) (arg1)->right = arg2;
21848 }
21849
21850
21851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
21852   int jresult ;
21853   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21854   int result;
21855
21856   arg1 = (Dali::Rect< int > *)jarg1;
21857   result = (int) ((arg1)->right);
21858   jresult = result;
21859   return jresult;
21860 }
21861
21862
21863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
21864   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21865   int arg2 ;
21866
21867   arg1 = (Dali::Rect< int > *)jarg1;
21868   arg2 = (int)jarg2;
21869   if (arg1) (arg1)->width = arg2;
21870 }
21871
21872
21873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
21874   int jresult ;
21875   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21876   int result;
21877
21878   arg1 = (Dali::Rect< int > *)jarg1;
21879   result = (int) ((arg1)->width);
21880   jresult = result;
21881   return jresult;
21882 }
21883
21884
21885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
21886   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21887   int arg2 ;
21888
21889   arg1 = (Dali::Rect< int > *)jarg1;
21890   arg2 = (int)jarg2;
21891   if (arg1) (arg1)->bottom = arg2;
21892 }
21893
21894
21895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
21896   int jresult ;
21897   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21898   int result;
21899
21900   arg1 = (Dali::Rect< int > *)jarg1;
21901   result = (int) ((arg1)->bottom);
21902   jresult = result;
21903   return jresult;
21904 }
21905
21906
21907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
21908   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21909   int arg2 ;
21910
21911   arg1 = (Dali::Rect< int > *)jarg1;
21912   arg2 = (int)jarg2;
21913   if (arg1) (arg1)->height = arg2;
21914 }
21915
21916
21917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
21918   int jresult ;
21919   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21920   int result;
21921
21922   arg1 = (Dali::Rect< int > *)jarg1;
21923   result = (int) ((arg1)->height);
21924   jresult = result;
21925   return jresult;
21926 }
21927
21928
21929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
21930   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21931   int arg2 ;
21932
21933   arg1 = (Dali::Rect< int > *)jarg1;
21934   arg2 = (int)jarg2;
21935   if (arg1) (arg1)->top = arg2;
21936 }
21937
21938
21939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
21940   int jresult ;
21941   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21942   int result;
21943
21944   arg1 = (Dali::Rect< int > *)jarg1;
21945   result = (int) ((arg1)->top);
21946   jresult = result;
21947   return jresult;
21948 }
21949
21950
21951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
21952   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
21953
21954   arg1 = (Dali::Rect< int > *)jarg1;
21955   {
21956     try {
21957       delete arg1;
21958     } CALL_CATCH_EXCEPTION();
21959   }
21960
21961 }
21962
21963
21964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
21965   void * jresult ;
21966   Dali::Rect< float > *result = 0 ;
21967
21968   {
21969     try {
21970       result = (Dali::Rect< float > *)new Dali::Rect< float >();
21971     } CALL_CATCH_EXCEPTION(0);
21972   }
21973
21974   jresult = (void *)result;
21975   return jresult;
21976 }
21977
21978
21979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
21980   void * jresult ;
21981   float arg1 ;
21982   float arg2 ;
21983   float arg3 ;
21984   float arg4 ;
21985   Dali::Rect< float > *result = 0 ;
21986
21987   arg1 = (float)jarg1;
21988   arg2 = (float)jarg2;
21989   arg3 = (float)jarg4;
21990   arg4 = (float)jarg3;
21991   {
21992     try {
21993       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
21994     } CALL_CATCH_EXCEPTION(0);
21995   }
21996
21997   jresult = (void *)result;
21998   return jresult;
21999 }
22000
22001
22002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
22003   void * jresult ;
22004   Dali::Rect< float > *arg1 = 0 ;
22005   Dali::Rect< float > *result = 0 ;
22006
22007   arg1 = (Dali::Rect< float > *)jarg1;
22008   if (!arg1) {
22009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
22010     return 0;
22011   }
22012   {
22013     try {
22014       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
22015     } CALL_CATCH_EXCEPTION(0);
22016   }
22017
22018   jresult = (void *)result;
22019   return jresult;
22020 }
22021
22022
22023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
22024   void * jresult ;
22025   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22026   Dali::Rect< float > *arg2 = 0 ;
22027   Dali::Rect< float > *result = 0 ;
22028
22029   arg1 = (Dali::Rect< float > *)jarg1;
22030   arg2 = (Dali::Rect< float > *)jarg2;
22031   if (!arg2) {
22032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
22033     return 0;
22034   }
22035   {
22036     try {
22037       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
22038     } CALL_CATCH_EXCEPTION(0);
22039   }
22040
22041   jresult = (void *)result;
22042   return jresult;
22043 }
22044
22045
22046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
22047   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22048   float arg2 ;
22049   float arg3 ;
22050   float arg4 ;
22051   float arg5 ;
22052
22053   arg1 = (Dali::Rect< float > *)jarg1;
22054   arg2 = (float)jarg2;
22055   arg3 = (float)jarg3;
22056   arg4 = (float)jarg5;
22057   arg5 = (float)jarg4;
22058   {
22059     try {
22060       (arg1)->Set(arg2,arg3,arg4,arg5);
22061     } CALL_CATCH_EXCEPTION();
22062   }
22063
22064 }
22065
22066
22067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
22068   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22069   float arg2 ;
22070
22071   arg1 = (Dali::Rect< float > *)jarg1;
22072   arg2 = (float)jarg2;
22073   if (arg1) (arg1)->left = arg2;
22074 }
22075
22076
22077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
22078   float jresult ;
22079   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22080   float result;
22081
22082   arg1 = (Dali::Rect< float > *)jarg1;
22083   result = (float) ((arg1)->left);
22084   jresult = result;
22085   return jresult;
22086 }
22087
22088
22089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
22090   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22091   float arg2 ;
22092
22093   arg1 = (Dali::Rect< float > *)jarg1;
22094   arg2 = (float)jarg2;
22095   if (arg1) (arg1)->left = arg2;
22096 }
22097
22098
22099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
22100   float jresult ;
22101   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22102   float result;
22103
22104   arg1 = (Dali::Rect< float > *)jarg1;
22105   result = (float) ((arg1)->left);
22106   jresult = result;
22107   return jresult;
22108 }
22109
22110
22111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
22112   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22113   float arg2 ;
22114
22115   arg1 = (Dali::Rect< float > *)jarg1;
22116   arg2 = (float)jarg2;
22117   if (arg1) (arg1)->right = arg2;
22118 }
22119
22120
22121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
22122   float jresult ;
22123   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22124   float result;
22125
22126   arg1 = (Dali::Rect< float > *)jarg1;
22127   result = (float) ((arg1)->right);
22128   jresult = result;
22129   return jresult;
22130 }
22131
22132
22133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
22134   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22135   float arg2 ;
22136
22137   arg1 = (Dali::Rect< float > *)jarg1;
22138   arg2 = (float)jarg2;
22139   if (arg1) (arg1)->right = arg2;
22140 }
22141
22142
22143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
22144   float jresult ;
22145   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22146   float result;
22147
22148   arg1 = (Dali::Rect< float > *)jarg1;
22149   result = (float) ((arg1)->right);
22150   jresult = result;
22151   return jresult;
22152 }
22153
22154
22155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
22156   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22157   float arg2 ;
22158
22159   arg1 = (Dali::Rect< float > *)jarg1;
22160   arg2 = (float)jarg2;
22161   if (arg1) (arg1)->bottom = arg2;
22162 }
22163
22164
22165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
22166   float jresult ;
22167   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22168   float result;
22169
22170   arg1 = (Dali::Rect< float > *)jarg1;
22171   result = (float) ((arg1)->bottom);
22172   jresult = result;
22173   return jresult;
22174 }
22175
22176
22177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
22178   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22179   float arg2 ;
22180
22181   arg1 = (Dali::Rect< float > *)jarg1;
22182   arg2 = (float)jarg2;
22183   if (arg1) (arg1)->top = arg2;
22184 }
22185
22186
22187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
22188   float jresult ;
22189   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22190   float result;
22191
22192   arg1 = (Dali::Rect< float > *)jarg1;
22193   result = (float) ((arg1)->top);
22194   jresult = result;
22195   return jresult;
22196 }
22197
22198
22199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
22200   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
22201
22202   arg1 = (Dali::Rect< float > *)jarg1;
22203   {
22204     try {
22205       delete arg1;
22206     } CALL_CATCH_EXCEPTION();
22207   }
22208
22209 }
22210
22211
22212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
22213   int jresult ;
22214   int result;
22215
22216   result = (int)Dali::Vector< int >::BaseType;
22217   jresult = (int)result;
22218   return jresult;
22219 }
22220
22221
22222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
22223   void * jresult ;
22224   Dali::Vector< int > *result = 0 ;
22225
22226   {
22227     try {
22228       result = (Dali::Vector< int > *)new Dali::Vector< int >();
22229     } CALL_CATCH_EXCEPTION(0);
22230   }
22231
22232   jresult = (void *)result;
22233   return jresult;
22234 }
22235
22236
22237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
22238   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22239
22240   arg1 = (Dali::Vector< int > *)jarg1;
22241   {
22242     try {
22243       delete arg1;
22244     } CALL_CATCH_EXCEPTION();
22245   }
22246
22247 }
22248
22249
22250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
22251   void * jresult ;
22252   Dali::Vector< int > *arg1 = 0 ;
22253   Dali::Vector< int > *result = 0 ;
22254
22255   arg1 = (Dali::Vector< int > *)jarg1;
22256   if (!arg1) {
22257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
22258     return 0;
22259   }
22260   {
22261     try {
22262       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
22263     } CALL_CATCH_EXCEPTION(0);
22264   }
22265
22266   jresult = (void *)result;
22267   return jresult;
22268 }
22269
22270
22271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
22272   void * jresult ;
22273   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22274   Dali::Vector< int > *arg2 = 0 ;
22275   Dali::Vector< int > *result = 0 ;
22276
22277   arg1 = (Dali::Vector< int > *)jarg1;
22278   arg2 = (Dali::Vector< int > *)jarg2;
22279   if (!arg2) {
22280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
22281     return 0;
22282   }
22283   {
22284     try {
22285       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
22286     } CALL_CATCH_EXCEPTION(0);
22287   }
22288
22289   jresult = (void *)result;
22290   return jresult;
22291 }
22292
22293
22294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
22295   void * jresult ;
22296   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22297   Dali::Vector< int >::Iterator result;
22298
22299   arg1 = (Dali::Vector< int > *)jarg1;
22300   {
22301     try {
22302       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
22303     } CALL_CATCH_EXCEPTION(0);
22304   }
22305
22306   jresult = (void *)result;
22307   return jresult;
22308 }
22309
22310
22311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
22312   void * jresult ;
22313   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22314   Dali::Vector< int >::Iterator result;
22315
22316   arg1 = (Dali::Vector< int > *)jarg1;
22317   {
22318     try {
22319       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
22320     } CALL_CATCH_EXCEPTION(0);
22321   }
22322
22323   jresult = (void *)result;
22324   return jresult;
22325 }
22326
22327
22328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
22329   void * jresult ;
22330   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22331   Dali::Vector< int >::SizeType arg2 ;
22332   Dali::Vector< int >::ItemType *result = 0 ;
22333
22334   arg1 = (Dali::Vector< int > *)jarg1;
22335   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22336   {
22337     try {
22338       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
22339     } CALL_CATCH_EXCEPTION(0);
22340   }
22341
22342   jresult = (void *)result;
22343   return jresult;
22344 }
22345
22346
22347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
22348   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22349   Dali::Vector< int >::ItemType *arg2 = 0 ;
22350   Dali::Vector< int >::ItemType temp2 ;
22351
22352   arg1 = (Dali::Vector< int > *)jarg1;
22353   temp2 = (Dali::Vector< int >::ItemType)jarg2;
22354   arg2 = &temp2;
22355   {
22356     try {
22357       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
22358     } CALL_CATCH_EXCEPTION();
22359   }
22360
22361 }
22362
22363
22364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
22365   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22366   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22367   Dali::Vector< int >::ItemType *arg3 = 0 ;
22368   Dali::Vector< int >::ItemType temp3 ;
22369
22370   arg1 = (Dali::Vector< int > *)jarg1;
22371   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22372   temp3 = (Dali::Vector< int >::ItemType)jarg3;
22373   arg3 = &temp3;
22374   {
22375     try {
22376       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
22377     } CALL_CATCH_EXCEPTION();
22378   }
22379
22380 }
22381
22382
22383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
22384   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22385   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22386   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
22387   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
22388
22389   arg1 = (Dali::Vector< int > *)jarg1;
22390   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22391   arg3 = (Dali::Vector< int >::Iterator)jarg3;
22392   arg4 = (Dali::Vector< int >::Iterator)jarg4;
22393   {
22394     try {
22395       (arg1)->Insert(arg2,arg3,arg4);
22396     } CALL_CATCH_EXCEPTION();
22397   }
22398
22399 }
22400
22401
22402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
22403   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22404   Dali::Vector< int >::SizeType arg2 ;
22405
22406   arg1 = (Dali::Vector< int > *)jarg1;
22407   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22408   {
22409     try {
22410       (arg1)->Reserve(arg2);
22411     } CALL_CATCH_EXCEPTION();
22412   }
22413
22414 }
22415
22416
22417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
22418   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22419   Dali::Vector< int >::SizeType arg2 ;
22420
22421   arg1 = (Dali::Vector< int > *)jarg1;
22422   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22423   {
22424     try {
22425       (arg1)->Resize(arg2);
22426     } CALL_CATCH_EXCEPTION();
22427   }
22428
22429 }
22430
22431
22432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
22433   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22434   Dali::Vector< int >::SizeType arg2 ;
22435   Dali::Vector< int >::ItemType *arg3 = 0 ;
22436   Dali::Vector< int >::ItemType temp3 ;
22437
22438   arg1 = (Dali::Vector< int > *)jarg1;
22439   arg2 = (Dali::Vector< int >::SizeType)jarg2;
22440   temp3 = (Dali::Vector< int >::ItemType)jarg3;
22441   arg3 = &temp3;
22442   {
22443     try {
22444       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
22445     } CALL_CATCH_EXCEPTION();
22446   }
22447
22448 }
22449
22450
22451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
22452   void * jresult ;
22453   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22454   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22455   Dali::Vector< int >::Iterator result;
22456
22457   arg1 = (Dali::Vector< int > *)jarg1;
22458   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22459   {
22460     try {
22461       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
22462     } CALL_CATCH_EXCEPTION(0);
22463   }
22464
22465   jresult = (void *)result;
22466   return jresult;
22467 }
22468
22469
22470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22471   void * jresult ;
22472   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22473   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22474   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
22475   Dali::Vector< int >::Iterator result;
22476
22477   arg1 = (Dali::Vector< int > *)jarg1;
22478   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22479   arg3 = (Dali::Vector< int >::Iterator)jarg3;
22480   {
22481     try {
22482       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
22483     } CALL_CATCH_EXCEPTION(0);
22484   }
22485
22486   jresult = (void *)result;
22487   return jresult;
22488 }
22489
22490
22491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
22492   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22493   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
22494
22495   arg1 = (Dali::Vector< int > *)jarg1;
22496   arg2 = (Dali::Vector< int >::Iterator)jarg2;
22497   {
22498     try {
22499       (arg1)->Remove(arg2);
22500     } CALL_CATCH_EXCEPTION();
22501   }
22502
22503 }
22504
22505
22506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
22507   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22508   Dali::Vector< int > *arg2 = 0 ;
22509
22510   arg1 = (Dali::Vector< int > *)jarg1;
22511   arg2 = (Dali::Vector< int > *)jarg2;
22512   if (!arg2) {
22513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
22514     return ;
22515   }
22516   {
22517     try {
22518       (arg1)->Swap(*arg2);
22519     } CALL_CATCH_EXCEPTION();
22520   }
22521
22522 }
22523
22524
22525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
22526   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22527
22528   arg1 = (Dali::Vector< int > *)jarg1;
22529   {
22530     try {
22531       (arg1)->Clear();
22532     } CALL_CATCH_EXCEPTION();
22533   }
22534
22535 }
22536
22537
22538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
22539   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
22540
22541   arg1 = (Dali::Vector< int > *)jarg1;
22542   {
22543     try {
22544       (arg1)->Release();
22545     } CALL_CATCH_EXCEPTION();
22546   }
22547
22548 }
22549
22550
22551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
22552   int jresult ;
22553   int result;
22554
22555   result = (int)Dali::Vector< float >::BaseType;
22556   jresult = (int)result;
22557   return jresult;
22558 }
22559
22560
22561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
22562   void * jresult ;
22563   Dali::Vector< float > *result = 0 ;
22564
22565   {
22566     try {
22567       result = (Dali::Vector< float > *)new Dali::Vector< float >();
22568     } CALL_CATCH_EXCEPTION(0);
22569   }
22570
22571   jresult = (void *)result;
22572   return jresult;
22573 }
22574
22575
22576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
22577   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22578
22579   arg1 = (Dali::Vector< float > *)jarg1;
22580   {
22581     try {
22582       delete arg1;
22583     } CALL_CATCH_EXCEPTION();
22584   }
22585
22586 }
22587
22588
22589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
22590   void * jresult ;
22591   Dali::Vector< float > *arg1 = 0 ;
22592   Dali::Vector< float > *result = 0 ;
22593
22594   arg1 = (Dali::Vector< float > *)jarg1;
22595   if (!arg1) {
22596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
22597     return 0;
22598   }
22599   {
22600     try {
22601       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
22602     } CALL_CATCH_EXCEPTION(0);
22603   }
22604
22605   jresult = (void *)result;
22606   return jresult;
22607 }
22608
22609
22610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
22611   void * jresult ;
22612   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22613   Dali::Vector< float > *arg2 = 0 ;
22614   Dali::Vector< float > *result = 0 ;
22615
22616   arg1 = (Dali::Vector< float > *)jarg1;
22617   arg2 = (Dali::Vector< float > *)jarg2;
22618   if (!arg2) {
22619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
22620     return 0;
22621   }
22622   {
22623     try {
22624       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
22625     } CALL_CATCH_EXCEPTION(0);
22626   }
22627
22628   jresult = (void *)result;
22629   return jresult;
22630 }
22631
22632
22633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
22634   void * jresult ;
22635   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22636   Dali::Vector< float >::Iterator result;
22637
22638   arg1 = (Dali::Vector< float > *)jarg1;
22639   {
22640     try {
22641       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
22642     } CALL_CATCH_EXCEPTION(0);
22643   }
22644
22645   jresult = (void *)result;
22646   return jresult;
22647 }
22648
22649
22650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
22651   void * jresult ;
22652   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22653   Dali::Vector< float >::Iterator result;
22654
22655   arg1 = (Dali::Vector< float > *)jarg1;
22656   {
22657     try {
22658       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
22659     } CALL_CATCH_EXCEPTION(0);
22660   }
22661
22662   jresult = (void *)result;
22663   return jresult;
22664 }
22665
22666
22667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
22668   void * jresult ;
22669   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22670   Dali::Vector< float >::SizeType arg2 ;
22671   Dali::Vector< float >::ItemType *result = 0 ;
22672
22673   arg1 = (Dali::Vector< float > *)jarg1;
22674   arg2 = (Dali::Vector< float >::SizeType)jarg2;
22675   {
22676     try {
22677       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
22678     } CALL_CATCH_EXCEPTION(0);
22679   }
22680
22681   jresult = (void *)result;
22682   return jresult;
22683 }
22684
22685
22686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
22687   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22688   Dali::Vector< float >::ItemType *arg2 = 0 ;
22689   Dali::Vector< float >::ItemType temp2 ;
22690
22691   arg1 = (Dali::Vector< float > *)jarg1;
22692   temp2 = (Dali::Vector< float >::ItemType)jarg2;
22693   arg2 = &temp2;
22694   {
22695     try {
22696       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
22697     } CALL_CATCH_EXCEPTION();
22698   }
22699
22700 }
22701
22702
22703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
22704   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22705   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
22706   Dali::Vector< float >::ItemType *arg3 = 0 ;
22707   Dali::Vector< float >::ItemType temp3 ;
22708
22709   arg1 = (Dali::Vector< float > *)jarg1;
22710   arg2 = (Dali::Vector< float >::Iterator)jarg2;
22711   temp3 = (Dali::Vector< float >::ItemType)jarg3;
22712   arg3 = &temp3;
22713   {
22714     try {
22715       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
22716     } CALL_CATCH_EXCEPTION();
22717   }
22718
22719 }
22720
22721
22722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
22723   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22724   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
22725   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
22726   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
22727
22728   arg1 = (Dali::Vector< float > *)jarg1;
22729   arg2 = (Dali::Vector< float >::Iterator)jarg2;
22730   arg3 = (Dali::Vector< float >::Iterator)jarg3;
22731   arg4 = (Dali::Vector< float >::Iterator)jarg4;
22732   {
22733     try {
22734       (arg1)->Insert(arg2,arg3,arg4);
22735     } CALL_CATCH_EXCEPTION();
22736   }
22737
22738 }
22739
22740
22741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
22742   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22743   Dali::Vector< float >::SizeType arg2 ;
22744
22745   arg1 = (Dali::Vector< float > *)jarg1;
22746   arg2 = (Dali::Vector< float >::SizeType)jarg2;
22747   {
22748     try {
22749       (arg1)->Reserve(arg2);
22750     } CALL_CATCH_EXCEPTION();
22751   }
22752
22753 }
22754
22755 //// ========================= end of part 2 =============================
22756
22757 //// ========================== start part 3 ===============================
22758
22759
22760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
22761   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22762   Dali::Vector< float >::SizeType arg2 ;
22763
22764   arg1 = (Dali::Vector< float > *)jarg1;
22765   arg2 = (Dali::Vector< float >::SizeType)jarg2;
22766   {
22767     try {
22768       (arg1)->Resize(arg2);
22769     } CALL_CATCH_EXCEPTION();
22770   }
22771
22772 }
22773
22774
22775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
22776   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22777   Dali::Vector< float >::SizeType arg2 ;
22778   Dali::Vector< float >::ItemType *arg3 = 0 ;
22779   Dali::Vector< float >::ItemType temp3 ;
22780
22781   arg1 = (Dali::Vector< float > *)jarg1;
22782   arg2 = (Dali::Vector< float >::SizeType)jarg2;
22783   temp3 = (Dali::Vector< float >::ItemType)jarg3;
22784   arg3 = &temp3;
22785   {
22786     try {
22787       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
22788     } CALL_CATCH_EXCEPTION();
22789   }
22790
22791 }
22792
22793
22794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
22795   void * jresult ;
22796   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22797   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
22798   Dali::Vector< float >::Iterator result;
22799
22800   arg1 = (Dali::Vector< float > *)jarg1;
22801   arg2 = (Dali::Vector< float >::Iterator)jarg2;
22802   {
22803     try {
22804       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
22805     } CALL_CATCH_EXCEPTION(0);
22806   }
22807
22808   jresult = (void *)result;
22809   return jresult;
22810 }
22811
22812
22813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
22814   void * jresult ;
22815   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22816   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
22817   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
22818   Dali::Vector< float >::Iterator result;
22819
22820   arg1 = (Dali::Vector< float > *)jarg1;
22821   arg2 = (Dali::Vector< float >::Iterator)jarg2;
22822   arg3 = (Dali::Vector< float >::Iterator)jarg3;
22823   {
22824     try {
22825       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
22826     } CALL_CATCH_EXCEPTION(0);
22827   }
22828
22829   jresult = (void *)result;
22830   return jresult;
22831 }
22832
22833
22834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
22835   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22836   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
22837
22838   arg1 = (Dali::Vector< float > *)jarg1;
22839   arg2 = (Dali::Vector< float >::Iterator)jarg2;
22840   {
22841     try {
22842       (arg1)->Remove(arg2);
22843     } CALL_CATCH_EXCEPTION();
22844   }
22845
22846 }
22847
22848
22849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
22850   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22851   Dali::Vector< float > *arg2 = 0 ;
22852
22853   arg1 = (Dali::Vector< float > *)jarg1;
22854   arg2 = (Dali::Vector< float > *)jarg2;
22855   if (!arg2) {
22856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
22857     return ;
22858   }
22859   {
22860     try {
22861       (arg1)->Swap(*arg2);
22862     } CALL_CATCH_EXCEPTION();
22863   }
22864
22865 }
22866
22867
22868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
22869   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22870
22871   arg1 = (Dali::Vector< float > *)jarg1;
22872   {
22873     try {
22874       (arg1)->Clear();
22875     } CALL_CATCH_EXCEPTION();
22876   }
22877
22878 }
22879
22880
22881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
22882   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
22883
22884   arg1 = (Dali::Vector< float > *)jarg1;
22885   {
22886     try {
22887       (arg1)->Release();
22888     } CALL_CATCH_EXCEPTION();
22889   }
22890
22891 }
22892
22893
22894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
22895   int jresult ;
22896   int result;
22897
22898   result = (int)Dali::Vector< unsigned char >::BaseType;
22899   jresult = (int)result;
22900   return jresult;
22901 }
22902
22903
22904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
22905   void * jresult ;
22906   Dali::Vector< unsigned char > *result = 0 ;
22907
22908   {
22909     try {
22910       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
22911     } CALL_CATCH_EXCEPTION(0);
22912   }
22913
22914   jresult = (void *)result;
22915   return jresult;
22916 }
22917
22918
22919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
22920   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
22921
22922   arg1 = (Dali::Vector< unsigned char > *)jarg1;
22923   {
22924     try {
22925       delete arg1;
22926     } CALL_CATCH_EXCEPTION();
22927   }
22928
22929 }
22930
22931
22932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
22933   void * jresult ;
22934   Dali::Vector< unsigned char > *arg1 = 0 ;
22935   Dali::Vector< unsigned char > *result = 0 ;
22936
22937   arg1 = (Dali::Vector< unsigned char > *)jarg1;
22938   if (!arg1) {
22939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
22940     return 0;
22941   }
22942   {
22943     try {
22944       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
22945     } CALL_CATCH_EXCEPTION(0);
22946   }
22947
22948   jresult = (void *)result;
22949   return jresult;
22950 }
22951
22952
22953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
22954   void * jresult ;
22955   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
22956   Dali::Vector< unsigned char > *arg2 = 0 ;
22957   Dali::Vector< unsigned char > *result = 0 ;
22958
22959   arg1 = (Dali::Vector< unsigned char > *)jarg1;
22960   arg2 = (Dali::Vector< unsigned char > *)jarg2;
22961   if (!arg2) {
22962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
22963     return 0;
22964   }
22965   {
22966     try {
22967       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
22968     } CALL_CATCH_EXCEPTION(0);
22969   }
22970
22971   jresult = (void *)result;
22972   return jresult;
22973 }
22974
22975
22976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
22977   void * jresult ;
22978   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
22979   Dali::Vector< unsigned char >::Iterator result;
22980
22981   arg1 = (Dali::Vector< unsigned char > *)jarg1;
22982   {
22983     try {
22984       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
22985     } CALL_CATCH_EXCEPTION(0);
22986   }
22987
22988   jresult = (void *)result;
22989   return jresult;
22990 }
22991
22992
22993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
22994   void * jresult ;
22995   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
22996   Dali::Vector< unsigned char >::Iterator result;
22997
22998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
22999   {
23000     try {
23001       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
23002     } CALL_CATCH_EXCEPTION(0);
23003   }
23004
23005   jresult = (void *)result;
23006   return jresult;
23007 }
23008
23009
23010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23011   void * jresult ;
23012   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23013   Dali::Vector< unsigned char >::SizeType arg2 ;
23014   Dali::Vector< unsigned char >::ItemType *result = 0 ;
23015
23016   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23017   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23018   {
23019     try {
23020       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
23021     } CALL_CATCH_EXCEPTION(0);
23022   }
23023
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
23030   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23031   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
23032   Dali::Vector< unsigned char >::ItemType temp2 ;
23033
23034   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23035   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
23036   arg2 = &temp2;
23037   {
23038     try {
23039       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
23040     } CALL_CATCH_EXCEPTION();
23041   }
23042
23043 }
23044
23045
23046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
23047   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23048   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23049   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
23050   Dali::Vector< unsigned char >::ItemType temp3 ;
23051
23052   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23053   arg2 = jarg2;
23054   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
23055   arg3 = &temp3;
23056   {
23057     try {
23058       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
23059     } CALL_CATCH_EXCEPTION();
23060   }
23061
23062
23063
23064 }
23065
23066
23067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
23068   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23069   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23070   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23071   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23072
23073   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23074   arg2 = jarg2;
23075   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
23076   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
23077   {
23078     try {
23079       (arg1)->Insert(arg2,arg3,arg4);
23080     } CALL_CATCH_EXCEPTION();
23081   }
23082
23083
23084
23085 }
23086
23087
23088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
23089   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23090   Dali::Vector< unsigned char >::SizeType arg2 ;
23091
23092   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23093   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23094   {
23095     try {
23096       (arg1)->Reserve(arg2);
23097     } CALL_CATCH_EXCEPTION();
23098   }
23099
23100 }
23101
23102
23103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23104   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23105   Dali::Vector< unsigned char >::SizeType arg2 ;
23106
23107   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23108   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23109   {
23110     try {
23111       (arg1)->Resize(arg2);
23112     } CALL_CATCH_EXCEPTION();
23113   }
23114
23115 }
23116
23117
23118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
23119   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23120   Dali::Vector< unsigned char >::SizeType arg2 ;
23121   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
23122   Dali::Vector< unsigned char >::ItemType temp3 ;
23123
23124   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23125   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
23126   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
23127   arg3 = &temp3;
23128   {
23129     try {
23130       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
23131     } CALL_CATCH_EXCEPTION();
23132   }
23133
23134 }
23135
23136
23137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
23138   void * jresult ;
23139   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23140   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23141   Dali::Vector< unsigned char >::Iterator result;
23142
23143   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23144   arg2 = jarg2;
23145   {
23146     try {
23147       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
23148     } CALL_CATCH_EXCEPTION(0);
23149   }
23150
23151   jresult = (void *)result;
23152
23153
23154   return jresult;
23155 }
23156
23157
23158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
23159   void * jresult ;
23160   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23161   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23162   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23163   Dali::Vector< unsigned char >::Iterator result;
23164
23165   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23166   arg2 = jarg2;
23167   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
23168   {
23169     try {
23170       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
23171     } CALL_CATCH_EXCEPTION(0);
23172   }
23173
23174   jresult = (void *)result;
23175
23176
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
23182   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23183   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
23184
23185   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23186   arg2 = jarg2;
23187   {
23188     try {
23189       (arg1)->Remove(arg2);
23190     } CALL_CATCH_EXCEPTION();
23191   }
23192
23193
23194
23195 }
23196
23197
23198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
23199   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23200   Dali::Vector< unsigned char > *arg2 = 0 ;
23201
23202   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23203   arg2 = (Dali::Vector< unsigned char > *)jarg2;
23204   if (!arg2) {
23205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
23206     return ;
23207   }
23208   {
23209     try {
23210       (arg1)->Swap(*arg2);
23211     } CALL_CATCH_EXCEPTION();
23212   }
23213
23214 }
23215
23216
23217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
23218   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23219
23220   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23221   {
23222     try {
23223       (arg1)->Clear();
23224     } CALL_CATCH_EXCEPTION();
23225   }
23226
23227 }
23228
23229
23230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
23231   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
23232
23233   arg1 = (Dali::Vector< unsigned char > *)jarg1;
23234   {
23235     try {
23236       (arg1)->Release();
23237     } CALL_CATCH_EXCEPTION();
23238   }
23239
23240 }
23241
23242
23243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
23244   int jresult ;
23245   int result;
23246
23247   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
23248   jresult = (int)result;
23249   return jresult;
23250 }
23251
23252
23253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
23254   void * jresult ;
23255   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23256
23257   {
23258     try {
23259       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
23260     } CALL_CATCH_EXCEPTION(0);
23261   }
23262
23263   jresult = (void *)result;
23264   return jresult;
23265 }
23266
23267
23268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
23269   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23270
23271   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23272   {
23273     try {
23274       delete arg1;
23275     } CALL_CATCH_EXCEPTION();
23276   }
23277
23278 }
23279
23280
23281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
23282   void * jresult ;
23283   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
23284   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23285
23286   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23287   if (!arg1) {
23288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
23289     return 0;
23290   }
23291   {
23292     try {
23293       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
23294     } CALL_CATCH_EXCEPTION(0);
23295   }
23296
23297   jresult = (void *)result;
23298   return jresult;
23299 }
23300
23301
23302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
23303   void * jresult ;
23304   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23305   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
23306   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
23307
23308   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23309   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
23310   if (!arg2) {
23311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
23312     return 0;
23313   }
23314   {
23315     try {
23316       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
23317     } CALL_CATCH_EXCEPTION(0);
23318   }
23319
23320   jresult = (void *)result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
23326   void * jresult ;
23327   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23328   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23329
23330   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23331   {
23332     try {
23333       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
23334     } CALL_CATCH_EXCEPTION(0);
23335   }
23336
23337   jresult = (void *)result;
23338   return jresult;
23339 }
23340
23341
23342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
23343   void * jresult ;
23344   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23345   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23346
23347   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23348   {
23349     try {
23350       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
23351     } CALL_CATCH_EXCEPTION(0);
23352   }
23353
23354   jresult = (void *)result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
23360   void * jresult ;
23361   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23362   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23363   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
23364
23365   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23366   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23367   {
23368     try {
23369       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
23370     } CALL_CATCH_EXCEPTION(0);
23371   }
23372
23373   jresult = (void *)result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
23379   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23380   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
23381
23382   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23383   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
23384   if (!arg2) {
23385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23386     return ;
23387   }
23388   {
23389     try {
23390       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
23391     } CALL_CATCH_EXCEPTION();
23392   }
23393
23394 }
23395
23396
23397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
23398   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23399   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23400   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
23401
23402   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23403   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23404   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
23405   if (!arg3) {
23406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23407     return ;
23408   }
23409   {
23410     try {
23411       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
23412     } CALL_CATCH_EXCEPTION();
23413   }
23414
23415 }
23416
23417
23418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
23419   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23420   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23421   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23422   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23423
23424   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23425   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23426   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
23427   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
23428   {
23429     try {
23430       (arg1)->Insert(arg2,arg3,arg4);
23431     } CALL_CATCH_EXCEPTION();
23432   }
23433
23434 }
23435
23436
23437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
23438   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23439   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23440
23441   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23442   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23443   {
23444     try {
23445       (arg1)->Reserve(arg2);
23446     } CALL_CATCH_EXCEPTION();
23447   }
23448
23449 }
23450
23451
23452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
23453   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23454   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23455
23456   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23457   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23458   {
23459     try {
23460       (arg1)->Resize(arg2);
23461     } CALL_CATCH_EXCEPTION();
23462   }
23463
23464 }
23465
23466
23467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
23468   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23469   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
23470   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
23471
23472   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23473   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
23474   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
23475   if (!arg3) {
23476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
23477     return ;
23478   }
23479   {
23480     try {
23481       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
23482     } CALL_CATCH_EXCEPTION();
23483   }
23484
23485 }
23486
23487
23488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
23489   void * jresult ;
23490   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23491   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23492   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23493
23494   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23495   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23496   {
23497     try {
23498       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
23499     } CALL_CATCH_EXCEPTION(0);
23500   }
23501
23502   jresult = (void *)result;
23503   return jresult;
23504 }
23505
23506
23507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
23508   void * jresult ;
23509   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23510   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23511   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23512   Dali::Vector< Dali::Uint16Pair >::Iterator result;
23513
23514   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23515   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23516   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
23517   {
23518     try {
23519       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
23520     } CALL_CATCH_EXCEPTION(0);
23521   }
23522
23523   jresult = (void *)result;
23524   return jresult;
23525 }
23526
23527
23528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
23529   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23530   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
23531
23532   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23533   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
23534   {
23535     try {
23536       (arg1)->Remove(arg2);
23537     } CALL_CATCH_EXCEPTION();
23538   }
23539
23540 }
23541
23542
23543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
23544   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23545   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
23546
23547   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23548   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
23549   if (!arg2) {
23550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
23551     return ;
23552   }
23553   {
23554     try {
23555       (arg1)->Swap(*arg2);
23556     } CALL_CATCH_EXCEPTION();
23557   }
23558
23559 }
23560
23561
23562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
23563   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23564
23565   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23566   {
23567     try {
23568       (arg1)->Clear();
23569     } CALL_CATCH_EXCEPTION();
23570   }
23571
23572 }
23573
23574
23575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
23576   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
23577
23578   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
23579   {
23580     try {
23581       (arg1)->Release();
23582     } CALL_CATCH_EXCEPTION();
23583   }
23584
23585 }
23586
23587
23588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
23589   void * jresult ;
23590   Dali::Signal< void () > *result = 0 ;
23591
23592   {
23593     try {
23594       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
23595     } CALL_CATCH_EXCEPTION(0);
23596   }
23597
23598   jresult = (void *)result;
23599   return jresult;
23600 }
23601
23602
23603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
23604   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23605
23606   arg1 = (Dali::Signal< void () > *)jarg1;
23607   {
23608     try {
23609       delete arg1;
23610     } CALL_CATCH_EXCEPTION();
23611   }
23612
23613 }
23614
23615
23616 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
23617   bool jresult ;
23618   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23619   bool result;
23620
23621   arg1 = (Dali::Signal< void () > *)jarg1;
23622   {
23623     try {
23624       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
23625     } CALL_CATCH_EXCEPTION(0);
23626   }
23627
23628   jresult = result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
23634   unsigned long jresult ;
23635   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23636   std::size_t result;
23637
23638   arg1 = (Dali::Signal< void () > *)jarg1;
23639   {
23640     try {
23641       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
23642     } CALL_CATCH_EXCEPTION(0);
23643   }
23644
23645   jresult = (unsigned long)result;
23646   return jresult;
23647 }
23648
23649
23650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
23651   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23652   void (*arg2)() = (void (*)()) 0 ;
23653
23654   arg1 = (Dali::Signal< void () > *)jarg1;
23655   arg2 = (void (*)())jarg2;
23656   {
23657     try {
23658       (arg1)->Connect(arg2);
23659     } CALL_CATCH_EXCEPTION();
23660   }
23661
23662 }
23663
23664
23665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
23666   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23667   void (*arg2)() = (void (*)()) 0 ;
23668
23669   arg1 = (Dali::Signal< void () > *)jarg1;
23670   arg2 = (void (*)())jarg2;
23671   {
23672     try {
23673       (arg1)->Disconnect(arg2);
23674     } CALL_CATCH_EXCEPTION();
23675   }
23676
23677 }
23678
23679
23680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
23681   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23682   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
23683   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
23684
23685   arg1 = (Dali::Signal< void () > *)jarg1;
23686   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
23687   arg3 = (Dali::FunctorDelegate *)jarg3;
23688   {
23689     try {
23690       (arg1)->Connect(arg2,arg3);
23691     } CALL_CATCH_EXCEPTION();
23692   }
23693
23694 }
23695
23696
23697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
23698   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
23699
23700   arg1 = (Dali::Signal< void () > *)jarg1;
23701   {
23702     try {
23703       (arg1)->Emit();
23704     } CALL_CATCH_EXCEPTION();
23705   }
23706
23707 }
23708
23709
23710 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
23711   bool jresult ;
23712   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
23713   bool result;
23714
23715   arg1 = (Dali::Signal< void (float) > *)jarg1;
23716   {
23717     try {
23718       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
23719     } CALL_CATCH_EXCEPTION(0);
23720   }
23721
23722   jresult = result;
23723   return jresult;
23724 }
23725
23726
23727 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
23728   unsigned long jresult ;
23729   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
23730   std::size_t result;
23731
23732   arg1 = (Dali::Signal< void (float) > *)jarg1;
23733   {
23734     try {
23735       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
23736     } CALL_CATCH_EXCEPTION(0);
23737   }
23738
23739   jresult = (unsigned long)result;
23740   return jresult;
23741 }
23742
23743
23744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
23745   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
23746   void (*arg2)(float) = (void (*)(float)) 0 ;
23747
23748   arg1 = (Dali::Signal< void (float) > *)jarg1;
23749   arg2 = (void (*)(float))jarg2;
23750   {
23751     try {
23752       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
23753     } CALL_CATCH_EXCEPTION();
23754   }
23755
23756 }
23757
23758
23759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
23760   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
23761   void (*arg2)(float) = (void (*)(float)) 0 ;
23762
23763   arg1 = (Dali::Signal< void (float) > *)jarg1;
23764   arg2 = (void (*)(float))jarg2;
23765   {
23766     try {
23767       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
23768     } CALL_CATCH_EXCEPTION();
23769   }
23770
23771 }
23772
23773
23774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
23775   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
23776   float arg2 ;
23777
23778   arg1 = (Dali::Signal< void (float) > *)jarg1;
23779   arg2 = (float)jarg2;
23780   {
23781     try {
23782       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
23783     } CALL_CATCH_EXCEPTION();
23784   }
23785
23786 }
23787
23788
23789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
23790   void * jresult ;
23791   Dali::Signal< void (float) > *result = 0 ;
23792
23793   {
23794     try {
23795       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
23796     } CALL_CATCH_EXCEPTION(0);
23797   }
23798
23799   jresult = (void *)result;
23800   return jresult;
23801 }
23802
23803
23804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
23805   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
23806
23807   arg1 = (Dali::Signal< void (float) > *)jarg1;
23808   {
23809     try {
23810       delete arg1;
23811     } CALL_CATCH_EXCEPTION();
23812   }
23813
23814 }
23815
23816
23817 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
23818   bool jresult ;
23819   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
23820   bool result;
23821
23822   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
23823   {
23824     try {
23825       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
23826     } CALL_CATCH_EXCEPTION(0);
23827   }
23828
23829   jresult = result;
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
23835   unsigned long jresult ;
23836   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
23837   std::size_t result;
23838
23839   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
23840   {
23841     try {
23842       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
23843     } CALL_CATCH_EXCEPTION(0);
23844   }
23845
23846   jresult = (unsigned long)result;
23847   return jresult;
23848 }
23849
23850
23851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
23852   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
23853   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
23854
23855   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
23856   arg2 = (void (*)(Dali::BaseHandle))jarg2;
23857   {
23858     try {
23859       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
23860     } CALL_CATCH_EXCEPTION();
23861   }
23862
23863 }
23864
23865
23866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
23867   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
23868   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
23869
23870   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
23871   arg2 = (void (*)(Dali::BaseHandle))jarg2;
23872   {
23873     try {
23874       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
23875     } CALL_CATCH_EXCEPTION();
23876   }
23877
23878 }
23879
23880
23881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
23882   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
23883   Dali::BaseHandle arg2 ;
23884   Dali::BaseHandle *argp2 ;
23885
23886   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
23887   argp2 = (Dali::BaseHandle *)jarg2;
23888   if (!argp2) {
23889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23890     return ;
23891   }
23892   arg2 = *argp2;
23893   {
23894     try {
23895       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
23896     } CALL_CATCH_EXCEPTION();
23897   }
23898
23899 }
23900
23901
23902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
23903   void * jresult ;
23904   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
23905
23906   {
23907     try {
23908       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
23909     } CALL_CATCH_EXCEPTION(0);
23910   }
23911
23912   jresult = (void *)result;
23913   return jresult;
23914 }
23915
23916
23917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
23918   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
23919
23920   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
23921   {
23922     try {
23923       delete arg1;
23924     } CALL_CATCH_EXCEPTION();
23925   }
23926
23927 }
23928
23929
23930 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
23931   bool jresult ;
23932   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
23933   bool result;
23934
23935   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
23936   {
23937     try {
23938       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
23939     } CALL_CATCH_EXCEPTION(0);
23940   }
23941
23942   jresult = result;
23943   return jresult;
23944 }
23945
23946
23947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
23948   unsigned long jresult ;
23949   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
23950   std::size_t result;
23951
23952   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
23953   {
23954     try {
23955       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
23956     } CALL_CATCH_EXCEPTION(0);
23957   }
23958
23959   jresult = (unsigned long)result;
23960   return jresult;
23961 }
23962
23963
23964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
23965   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
23966   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
23967
23968   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
23969   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
23970   {
23971     try {
23972       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
23973     } CALL_CATCH_EXCEPTION();
23974   }
23975
23976 }
23977
23978
23979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
23980   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
23981   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
23982
23983   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
23984   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
23985   {
23986     try {
23987       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
23988     } CALL_CATCH_EXCEPTION();
23989   }
23990
23991 }
23992
23993
23994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
23995   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
23996   Dali::PropertyNotification *arg2 = 0 ;
23997
23998   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
23999   arg2 = (Dali::PropertyNotification *)jarg2;
24000   if (!arg2) {
24001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
24002     return ;
24003   }
24004   {
24005     try {
24006       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
24007     } CALL_CATCH_EXCEPTION();
24008   }
24009
24010 }
24011
24012
24013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
24014   void * jresult ;
24015   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
24016
24017   {
24018     try {
24019       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
24020     } CALL_CATCH_EXCEPTION(0);
24021   }
24022
24023   jresult = (void *)result;
24024   return jresult;
24025 }
24026
24027
24028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
24029   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
24030
24031   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
24032   {
24033     try {
24034       delete arg1;
24035     } CALL_CATCH_EXCEPTION();
24036   }
24037
24038 }
24039
24040
24041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
24042   void * jresult ;
24043   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
24044
24045   {
24046     try {
24047       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
24048     } CALL_CATCH_EXCEPTION(0);
24049   }
24050
24051   jresult = (void *)result;
24052   return jresult;
24053 }
24054
24055
24056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
24057   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
24058
24059   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
24060   {
24061     try {
24062       delete arg1;
24063     } CALL_CATCH_EXCEPTION();
24064   }
24065
24066 }
24067
24068
24069 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
24070   bool jresult ;
24071   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24072   bool result;
24073
24074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24075   {
24076     try {
24077       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);
24078     } CALL_CATCH_EXCEPTION(0);
24079   }
24080
24081   jresult = result;
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24087   unsigned long jresult ;
24088   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24089   std::size_t result;
24090
24091   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24092   {
24093     try {
24094       result = Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *)arg1);
24095     } CALL_CATCH_EXCEPTION(0);
24096   }
24097
24098   jresult = (unsigned long)result;
24099   return jresult;
24100 }
24101
24102
24103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24104   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24105   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
24106
24107   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24108   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
24109   {
24110     try {
24111       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24112     } CALL_CATCH_EXCEPTION();
24113   }
24114
24115 }
24116
24117
24118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24119   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24120   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
24121
24122   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24123   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
24124   {
24125     try {
24126       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24127     } CALL_CATCH_EXCEPTION();
24128   }
24129
24130 }
24131
24132
24133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
24134   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24135   Dali::Actor arg2 ;
24136   Dali::LongPressGesture *arg3 = 0 ;
24137   Dali::Actor *argp2 ;
24138
24139   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24140   argp2 = (Dali::Actor *)jarg2;
24141   if (!argp2) {
24142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24143     return ;
24144   }
24145   arg2 = *argp2;
24146   arg3 = (Dali::LongPressGesture *)jarg3;
24147   if (!arg3) {
24148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
24149     return ;
24150   }
24151   {
24152     try {
24153       Dali_Signal_Sl_void_Sp_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
24154     } CALL_CATCH_EXCEPTION();
24155   }
24156
24157 }
24158
24159
24160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
24161   void * jresult ;
24162   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
24163
24164   {
24165     try {
24166       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
24167     } CALL_CATCH_EXCEPTION(0);
24168   }
24169
24170   jresult = (void *)result;
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
24176   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
24177
24178   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
24179   {
24180     try {
24181       delete arg1;
24182     } CALL_CATCH_EXCEPTION();
24183   }
24184
24185 }
24186
24187
24188 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
24189   bool jresult ;
24190   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24191   bool result;
24192
24193   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24194   {
24195     try {
24196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
24197     } CALL_CATCH_EXCEPTION(0);
24198   }
24199
24200   jresult = result;
24201   return jresult;
24202 }
24203
24204
24205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
24206   unsigned long jresult ;
24207   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24208   std::size_t result;
24209
24210   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24211   {
24212     try {
24213       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
24214     } CALL_CATCH_EXCEPTION(0);
24215   }
24216
24217   jresult = (unsigned long)result;
24218   return jresult;
24219 }
24220
24221
24222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
24223   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24224   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
24225
24226   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24227   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
24228   {
24229     try {
24230       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24231     } CALL_CATCH_EXCEPTION();
24232   }
24233
24234 }
24235
24236
24237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
24238   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24239   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
24240
24241   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24242   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
24243   {
24244     try {
24245       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24246     } CALL_CATCH_EXCEPTION();
24247   }
24248
24249 }
24250
24251
24252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
24253   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24254   Dali::KeyEvent *arg2 = 0 ;
24255
24256   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24257   arg2 = (Dali::KeyEvent *)jarg2;
24258   if (!arg2) {
24259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
24260     return ;
24261   }
24262   {
24263     try {
24264       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
24265     } CALL_CATCH_EXCEPTION();
24266   }
24267
24268 }
24269
24270
24271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
24272   void * jresult ;
24273   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
24274
24275   {
24276     try {
24277       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
24278     } CALL_CATCH_EXCEPTION(0);
24279   }
24280
24281   jresult = (void *)result;
24282   return jresult;
24283 }
24284
24285
24286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
24287   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
24288
24289   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
24290   {
24291     try {
24292       delete arg1;
24293     } CALL_CATCH_EXCEPTION();
24294   }
24295
24296 }
24297
24298 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
24299   bool jresult ;
24300   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24301   bool result;
24302
24303   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24304   {
24305     try {
24306       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
24307     } CALL_CATCH_EXCEPTION(0);
24308   }
24309
24310   jresult = result;
24311   return jresult;
24312 }
24313
24314
24315 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
24316   unsigned long jresult ;
24317   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24318   std::size_t result;
24319
24320   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24321   {
24322     try {
24323       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
24324     } CALL_CATCH_EXCEPTION(0);
24325   }
24326
24327   jresult = (unsigned long)result;
24328   return jresult;
24329 }
24330
24331
24332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
24333   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24334   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
24335
24336   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24337   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
24338   {
24339     try {
24340       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24341     } CALL_CATCH_EXCEPTION();
24342   }
24343
24344 }
24345
24346
24347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
24348   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24349   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
24350
24351   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24352   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
24353   {
24354     try {
24355       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24356     } CALL_CATCH_EXCEPTION();
24357   }
24358
24359 }
24360
24361
24362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
24363   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24364   Dali::WheelEvent *arg2 = 0 ;
24365
24366   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24367   arg2 = (Dali::WheelEvent *)jarg2;
24368   if (!arg2) {
24369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
24370     return ;
24371   }
24372   {
24373     try {
24374       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
24375     } CALL_CATCH_EXCEPTION();
24376   }
24377
24378 }
24379
24380
24381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
24382   void * jresult ;
24383   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
24384
24385   {
24386     try {
24387       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
24388     } CALL_CATCH_EXCEPTION(0);
24389   }
24390
24391   jresult = (void *)result;
24392   return jresult;
24393 }
24394
24395
24396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
24397   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
24398
24399   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
24400   {
24401     try {
24402       delete arg1;
24403     } CALL_CATCH_EXCEPTION();
24404   }
24405
24406 }
24407
24408
24409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
24410   void * jresult ;
24411   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24412
24413   {
24414     try {
24415       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
24416     } CALL_CATCH_EXCEPTION(0);
24417   }
24418
24419   jresult = (void *)result;
24420   return jresult;
24421 }
24422
24423
24424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
24425   void * jresult ;
24426   Dali::Radian arg1 ;
24427   Dali::Radian arg2 ;
24428   Dali::Radian *argp1 ;
24429   Dali::Radian *argp2 ;
24430   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24431
24432   argp1 = (Dali::Radian *)jarg1;
24433   if (!argp1) {
24434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
24435     return 0;
24436   }
24437   arg1 = *argp1;
24438   argp2 = (Dali::Radian *)jarg2;
24439   if (!argp2) {
24440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
24441     return 0;
24442   }
24443   arg2 = *argp2;
24444   {
24445     try {
24446       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
24447     } CALL_CATCH_EXCEPTION(0);
24448   }
24449
24450   jresult = (void *)result;
24451   return jresult;
24452 }
24453
24454
24455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
24456   void * jresult ;
24457   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
24458   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
24459
24460   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24461   if (!arg1) {
24462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
24463     return 0;
24464   }
24465   {
24466     try {
24467       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
24468     } CALL_CATCH_EXCEPTION(0);
24469   }
24470
24471   jresult = (void *)result;
24472   return jresult;
24473 }
24474
24475
24476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
24477   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24478   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
24479
24480   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24481   arg2 = (Dali::Radian *)jarg2;
24482   if (arg1) (arg1)->first = *arg2;
24483 }
24484
24485
24486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
24487   void * jresult ;
24488   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24489   Dali::Radian *result = 0 ;
24490
24491   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24492   result = (Dali::Radian *)& ((arg1)->first);
24493   jresult = (void *)result;
24494   return jresult;
24495 }
24496
24497
24498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
24499   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24500   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
24501
24502   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24503   arg2 = (Dali::Radian *)jarg2;
24504   if (arg1) (arg1)->second = *arg2;
24505 }
24506
24507
24508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
24509   void * jresult ;
24510   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24511   Dali::Radian *result = 0 ;
24512
24513   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24514   result = (Dali::Radian *)& ((arg1)->second);
24515   jresult = (void *)result;
24516   return jresult;
24517 }
24518
24519
24520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
24521   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
24522
24523   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
24524   {
24525     try {
24526       delete arg1;
24527     } CALL_CATCH_EXCEPTION();
24528   }
24529
24530 }
24531
24532
24533 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
24534   bool jresult ;
24535   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24536   bool result;
24537
24538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24539   {
24540     try {
24541       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);
24542     } CALL_CATCH_EXCEPTION(0);
24543   }
24544
24545   jresult = result;
24546   return jresult;
24547 }
24548
24549
24550 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24551   unsigned long jresult ;
24552   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24553   std::size_t result;
24554
24555   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24556   {
24557     try {
24558       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);
24559     } CALL_CATCH_EXCEPTION(0);
24560   }
24561
24562   jresult = (unsigned long)result;
24563   return jresult;
24564 }
24565
24566
24567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24568   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24569   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
24570
24571   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24572   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
24573   {
24574     try {
24575       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24576     } CALL_CATCH_EXCEPTION();
24577   }
24578
24579 }
24580
24581
24582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24583   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24584   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
24585
24586   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24587   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
24588   {
24589     try {
24590       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24591     } CALL_CATCH_EXCEPTION();
24592   }
24593
24594 }
24595
24596
24597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
24598   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24599   Dali::Actor arg2 ;
24600   Dali::PanGesture *arg3 = 0 ;
24601   Dali::Actor *argp2 ;
24602
24603   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24604   argp2 = (Dali::Actor *)jarg2;
24605   if (!argp2) {
24606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24607     return ;
24608   }
24609   arg2 = *argp2;
24610   arg3 = (Dali::PanGesture *)jarg3;
24611   if (!arg3) {
24612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
24613     return ;
24614   }
24615   {
24616     try {
24617       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
24618     } CALL_CATCH_EXCEPTION();
24619   }
24620
24621 }
24622
24623
24624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
24625   void * jresult ;
24626   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
24627
24628   {
24629     try {
24630       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
24631     } CALL_CATCH_EXCEPTION(0);
24632   }
24633
24634   jresult = (void *)result;
24635   return jresult;
24636 }
24637
24638
24639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
24640   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
24641
24642   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
24643   {
24644     try {
24645       delete arg1;
24646     } CALL_CATCH_EXCEPTION();
24647   }
24648
24649 }
24650
24651
24652 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
24653   bool jresult ;
24654   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
24655   bool result;
24656
24657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
24658   {
24659     try {
24660       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);
24661     } CALL_CATCH_EXCEPTION(0);
24662   }
24663
24664   jresult = result;
24665   return jresult;
24666 }
24667
24668
24669 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24670   unsigned long jresult ;
24671   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
24672   std::size_t result;
24673
24674   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
24675   {
24676     try {
24677       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);
24678     } CALL_CATCH_EXCEPTION(0);
24679   }
24680
24681   jresult = (unsigned long)result;
24682   return jresult;
24683 }
24684
24685
24686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24687   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
24688   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
24689
24690   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
24691   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
24692   {
24693     try {
24694       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24695     } CALL_CATCH_EXCEPTION();
24696   }
24697
24698 }
24699
24700
24701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24702   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
24703   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
24704
24705   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
24706   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
24707   {
24708     try {
24709       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24710     } CALL_CATCH_EXCEPTION();
24711   }
24712
24713 }
24714
24715
24716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
24717   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
24718   Dali::Actor arg2 ;
24719   Dali::PinchGesture *arg3 = 0 ;
24720   Dali::Actor *argp2 ;
24721
24722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
24723   argp2 = (Dali::Actor *)jarg2;
24724   if (!argp2) {
24725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24726     return ;
24727   }
24728   arg2 = *argp2;
24729   arg3 = (Dali::PinchGesture *)jarg3;
24730   if (!arg3) {
24731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
24732     return ;
24733   }
24734   {
24735     try {
24736       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
24737     } CALL_CATCH_EXCEPTION();
24738   }
24739
24740 }
24741
24742
24743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
24744   void * jresult ;
24745   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
24746
24747   {
24748     try {
24749       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
24750     } CALL_CATCH_EXCEPTION(0);
24751   }
24752
24753   jresult = (void *)result;
24754   return jresult;
24755 }
24756
24757
24758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
24759   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
24760
24761   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
24762   {
24763     try {
24764       delete arg1;
24765     } CALL_CATCH_EXCEPTION();
24766   }
24767
24768 }
24769
24770
24771 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
24772   bool jresult ;
24773   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
24774   bool result;
24775
24776   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
24777   {
24778     try {
24779       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);
24780     } CALL_CATCH_EXCEPTION(0);
24781   }
24782
24783   jresult = result;
24784   return jresult;
24785 }
24786
24787
24788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
24789   unsigned long jresult ;
24790   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
24791   std::size_t result;
24792
24793   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
24794   {
24795     try {
24796       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);
24797     } CALL_CATCH_EXCEPTION(0);
24798   }
24799
24800   jresult = (unsigned long)result;
24801   return jresult;
24802 }
24803
24804
24805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
24806   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
24807   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
24808
24809   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
24810   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
24811   {
24812     try {
24813       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
24814     } CALL_CATCH_EXCEPTION();
24815   }
24816
24817 }
24818
24819
24820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
24821   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
24822   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
24823
24824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
24825   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
24826   {
24827     try {
24828       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
24829     } CALL_CATCH_EXCEPTION();
24830   }
24831
24832 }
24833
24834
24835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
24836   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
24837   Dali::Actor arg2 ;
24838   Dali::TapGesture *arg3 = 0 ;
24839   Dali::Actor *argp2 ;
24840
24841   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
24842   argp2 = (Dali::Actor *)jarg2;
24843   if (!argp2) {
24844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24845     return ;
24846   }
24847   arg2 = *argp2;
24848   arg3 = (Dali::TapGesture *)jarg3;
24849   if (!arg3) {
24850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
24851     return ;
24852   }
24853   {
24854     try {
24855       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
24856     } CALL_CATCH_EXCEPTION();
24857   }
24858
24859 }
24860
24861
24862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
24863   void * jresult ;
24864   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
24865
24866   {
24867     try {
24868       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
24869     } CALL_CATCH_EXCEPTION(0);
24870   }
24871
24872   jresult = (void *)result;
24873   return jresult;
24874 }
24875
24876
24877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
24878   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
24879
24880   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
24881   {
24882     try {
24883       delete arg1;
24884     } CALL_CATCH_EXCEPTION();
24885   }
24886
24887 }
24888
24889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
24890   unsigned long jresult ;
24891   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
24892   std::size_t result = 0;
24893
24894   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
24895   {
24896     try {
24897       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);
24898     }CALL_CATCH_EXCEPTION(0);
24899   }
24900   jresult = (unsigned long)result;
24901   return jresult;
24902 }
24903
24904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
24905   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
24906   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
24907
24908   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
24909   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
24910   {
24911     try {
24912       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
24913     } CALL_CATCH_EXCEPTION();
24914   }
24915 }
24916
24917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
24918   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
24919   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
24920
24921   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
24922   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
24923   {
24924     try {
24925       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
24926     } CALL_CATCH_EXCEPTION();
24927   }
24928 }
24929
24930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
24931   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
24932   Dali::Actor arg2 ;
24933   //bool arg3 ;
24934   Dali::LayoutDirection::Type arg4 ;
24935   Dali::Actor *argp2 ;
24936
24937   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
24938   argp2 = (Dali::Actor *)jarg2;
24939   if (!argp2) {
24940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24941     return ;
24942   }
24943   arg2 = *argp2;
24944   //arg3 = jarg3 ? true : false;
24945   arg4 = (Dali::LayoutDirection::Type)jarg4;
24946   {
24947     try {
24948       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
24949     } CALL_CATCH_EXCEPTION();
24950   }
24951 }
24952
24953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
24954   void * jresult ;
24955   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
24956
24957   {
24958     try {
24959       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
24960     } CALL_CATCH_EXCEPTION(0);
24961   }
24962   jresult = (void *)result;
24963   return jresult;
24964 }
24965
24966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
24967   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
24968
24969   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
24970   {
24971     try {
24972       delete arg1;
24973     } CALL_CATCH_EXCEPTION();
24974   }
24975 }
24976
24977
24978 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) {
24979   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
24980   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
24981   if (director) {
24982     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);
24983   }
24984 }
24985
24986
24987 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) {
24988   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
24989   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
24990   if (director) {
24991     director->swig_connect_director(callback0, callback1, callback2);
24992   }
24993 }
24994
24995
24996 //// ========================= end of part 3 =============================
24997
24998 //// ========================== start part 4 =============================
24999
25000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
25001   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
25002   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25003   if (director) {
25004     director->swig_connect_director(callback0);
25005   }
25006 }
25007
25008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect_with_return(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback1_t callback1) {
25009   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
25010   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25011   if (director) {
25012     director->swig_connect_director_with_return(callback1);
25013   }
25014 }
25015
25016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
25017   void * jresult ;
25018   Dali::FrameCallbackInterface *result = 0 ;
25019
25020   {
25021     try {
25022       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
25023     } CALL_CATCH_EXCEPTION(0);
25024   }
25025
25026   jresult = (void *)result;
25027   return jresult;
25028 }
25029
25030
25031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
25032   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
25033   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25034
25035   Dali::Stage *arg1 = (Dali::Stage *) 0;
25036   Dali::Actor *arg3 = 0;
25037
25038   arg1 = (Dali::Stage *)jarg1;
25039   arg3 = (Dali::Actor *)jarg3;
25040
25041   if(arg3 == nullptr)
25042   {
25043     DevelStage::AddFrameCallback( *arg1, *arg2, Dali::Actor() );
25044   }
25045   else
25046   {
25047     DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
25048   }
25049   return;
25050 }
25051
25052
25053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
25054
25055   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
25056   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
25057
25058   Dali::Stage *arg1 = (Dali::Stage *) 0;
25059
25060   arg1 = (Dali::Stage *)jarg1;
25061
25062   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
25063   return;
25064 }
25065
25066
25067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
25068   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
25069   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
25070   if (director) {
25071     director->swig_connect_director(callback0);
25072   }
25073 }
25074
25075
25076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
25077   void * jresult ;
25078   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
25079
25080   {
25081     try {
25082       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
25083     } CALL_CATCH_EXCEPTION(0);
25084   }
25085
25086   jresult = (void *)result;
25087   return jresult;
25088 }
25089
25090
25091 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) {
25092   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
25093   if (director) {
25094     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
25095   }
25096 }
25097
25098
25099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
25100   void * jresult ;
25101   SwigDirector_WidgetImpl* result;
25102   {
25103     try {
25104       result = new SwigDirector_WidgetImpl();
25105     } CALL_CATCH_EXCEPTION(0);
25106   }
25107   jresult = result;
25108   return jresult;
25109 }
25110
25111
25112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
25113   void * jresult ;
25114   Dali::Widget *arg1 = 0 ;
25115   SwigDirector_WidgetImpl *result = 0 ;
25116
25117   arg1 = (Dali::Widget *)jarg1;
25118   if (!arg1) {
25119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
25120     return 0;
25121   }
25122   {
25123     try {
25124       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
25125     } CALL_CATCH_EXCEPTION(0);
25126   }
25127   jresult = (void*) result;
25128   return jresult;
25129 }
25130
25131
25132
25133 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
25134     return (Dali::SignalObserver *)jarg1;
25135 }
25136
25137 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
25138     return (Dali::ConnectionTrackerInterface *)jarg1;
25139 }
25140
25141 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
25142     return (Dali::BaseHandle *)jarg1;
25143 }
25144
25145 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
25146     return (Dali::BaseHandle *)jarg1;
25147 }
25148
25149 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
25150     return (Dali::BaseHandle *)jarg1;
25151 }
25152
25153 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
25154     return (Dali::BaseHandle *)jarg1;
25155 }
25156
25157 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
25158     return (Dali::BaseHandle *)jarg1;
25159 }
25160
25161 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
25162     return (Dali::BaseHandle *)jarg1;
25163 }
25164
25165 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
25166     return (Dali::BaseHandle *)jarg1;
25167 }
25168
25169 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
25170     return (Dali::BaseHandle *)jarg1;
25171 }
25172
25173 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
25174     return (Dali::BaseHandle *)jarg1;
25175 }
25176
25177 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
25178     return (Dali::BaseHandle *)jarg1;
25179 }
25180
25181 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
25182     return (Dali::BaseHandle *)jarg1;
25183 }
25184
25185 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
25186     return (Dali::BaseHandle *)jarg1;
25187 }
25188
25189 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
25190     return (Dali::Handle *)jarg1;
25191 }
25192
25193 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
25194     return (Dali::Handle *)jarg1;
25195 }
25196
25197 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
25198     return (Dali::BaseHandle *)jarg1;
25199 }
25200
25201 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
25202     return (Dali::BaseHandle *)jarg1;
25203 }
25204
25205 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
25206     return (Dali::Handle *)jarg1;
25207 }
25208
25209 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
25210     return (Dali::BaseHandle *)jarg1;
25211 }
25212
25213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
25214     return (Dali::BaseHandle *)jarg1;
25215 }
25216
25217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Wheel_SWIGUpcast(Dali::WheelEvent *jarg1) {
25218     return (Dali::BaseHandle *)jarg1;
25219 }
25220
25221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Key_SWIGUpcast(Dali::KeyEvent *jarg1) {
25222     return (Dali::BaseHandle *)jarg1;
25223 }
25224
25225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Gesture_SWIGUpcast(Dali::Gesture *jarg1) {
25226     return (Dali::BaseHandle *)jarg1;
25227 }
25228
25229 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
25230     return (Dali::Handle *)jarg1;
25231 }
25232
25233 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
25234     return (Dali::GestureDetector *)jarg1;
25235 }
25236
25237 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
25238     return (Dali::Gesture *)jarg1;
25239 }
25240
25241
25242 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
25243     return (Dali::RefObject *)jarg1;
25244 }
25245
25246 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
25247     return (Dali::Actor *)jarg1;
25248 }
25249
25250 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
25251     return (Dali::GestureDetector *)jarg1;
25252 }
25253
25254 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
25255     return (Dali::Gesture *)jarg1;
25256 }
25257
25258 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
25259     return (Dali::GestureDetector *)jarg1;
25260 }
25261
25262 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
25263     return (Dali::Gesture *)jarg1;
25264 }
25265
25266 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
25267     return (Dali::GestureDetector *)jarg1;
25268 }
25269
25270 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
25271     return (Dali::Gesture *)jarg1;
25272 }
25273
25274 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
25275     return (Dali::BaseHandle *)jarg1;
25276 }
25277
25278 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
25279     return (Dali::Handle *)jarg1;
25280 }
25281
25282 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
25283     return (Dali::Handle *)jarg1;
25284 }
25285
25286 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
25287     return (Dali::Handle *)jarg1;
25288 }
25289
25290 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
25291     return (Dali::RefObject *)jarg1;
25292 }
25293
25294 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
25295     return (Dali::Actor *)jarg1;
25296 }
25297
25298 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
25299     return (Dali::BaseHandle *)jarg1;
25300 }
25301
25302
25303 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
25304   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
25305   char * jresult = SWIG_csharp_string_callback((const char *)result);
25306   return jresult;
25307 }
25308
25309 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
25310   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
25311   return result;
25312 }
25313
25314
25315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
25316   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25317
25318   arg1 = (std::vector< unsigned int > *)jarg1;
25319   {
25320     try {
25321       (arg1)->clear();
25322     } CALL_CATCH_EXCEPTION();
25323   }
25324
25325 }
25326
25327
25328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
25329   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25330   unsigned int *arg2 = 0 ;
25331   unsigned int temp2 ;
25332
25333   arg1 = (std::vector< unsigned int > *)jarg1;
25334   temp2 = (unsigned int)jarg2;
25335   arg2 = &temp2;
25336   {
25337     try {
25338       (arg1)->push_back((unsigned int const &)*arg2);
25339     } CALL_CATCH_EXCEPTION();
25340   }
25341
25342 }
25343
25344
25345 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
25346   unsigned long jresult ;
25347   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25348   std::vector< unsigned int >::size_type result;
25349
25350   arg1 = (std::vector< unsigned int > *)jarg1;
25351   {
25352     try {
25353       result = ((std::vector< unsigned int > const *)arg1)->size();
25354     } CALL_CATCH_EXCEPTION(0);
25355   }
25356
25357   jresult = (unsigned long)result;
25358   return jresult;
25359 }
25360
25361
25362 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
25363   unsigned long jresult ;
25364   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25365   std::vector< unsigned int >::size_type result;
25366
25367   arg1 = (std::vector< unsigned int > *)jarg1;
25368   {
25369     try {
25370       result = ((std::vector< unsigned int > const *)arg1)->capacity();
25371     } CALL_CATCH_EXCEPTION(0);
25372   }
25373
25374   jresult = (unsigned long)result;
25375   return jresult;
25376 }
25377
25378
25379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
25380   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25381   std::vector< unsigned int >::size_type arg2 ;
25382
25383   arg1 = (std::vector< unsigned int > *)jarg1;
25384   arg2 = (std::vector< unsigned int >::size_type)jarg2;
25385   {
25386     try {
25387       (arg1)->reserve(arg2);
25388     } CALL_CATCH_EXCEPTION();
25389   }
25390
25391 }
25392
25393
25394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
25395   void * jresult ;
25396   std::vector< unsigned int > *result = 0 ;
25397
25398   {
25399     try {
25400       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
25401     } CALL_CATCH_EXCEPTION(0);
25402   }
25403
25404   jresult = (void *)result;
25405   return jresult;
25406 }
25407
25408
25409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
25410   void * jresult ;
25411   std::vector< unsigned int > *arg1 = 0 ;
25412   std::vector< unsigned int > *result = 0 ;
25413
25414   arg1 = (std::vector< unsigned int > *)jarg1;
25415   if (!arg1) {
25416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25417     return 0;
25418   }
25419   {
25420     try {
25421       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
25422     } CALL_CATCH_EXCEPTION(0);
25423   }
25424
25425   jresult = (void *)result;
25426   return jresult;
25427 }
25428
25429
25430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
25431   void * jresult ;
25432   int arg1 ;
25433   std::vector< unsigned int > *result = 0 ;
25434
25435   arg1 = (int)jarg1;
25436   {
25437     try {
25438       try {
25439         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
25440       }
25441       catch(std::out_of_range &_e) {
25442         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25443         return 0;
25444       }
25445
25446     } CALL_CATCH_EXCEPTION(0);
25447   }
25448
25449   jresult = (void *)result;
25450   return jresult;
25451 }
25452
25453
25454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
25455   unsigned int jresult ;
25456   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25457   int arg2 ;
25458   unsigned int result;
25459
25460   arg1 = (std::vector< unsigned int > *)jarg1;
25461   arg2 = (int)jarg2;
25462   {
25463     try {
25464       try {
25465         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
25466       }
25467       catch(std::out_of_range &_e) {
25468         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25469         return 0;
25470       }
25471
25472     } CALL_CATCH_EXCEPTION(0);
25473   }
25474
25475   jresult = result;
25476   return jresult;
25477 }
25478
25479
25480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
25481   unsigned int jresult ;
25482   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25483   int arg2 ;
25484   unsigned int *result = 0 ;
25485
25486   arg1 = (std::vector< unsigned int > *)jarg1;
25487   arg2 = (int)jarg2;
25488   {
25489     try {
25490       try {
25491         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
25492       }
25493       catch(std::out_of_range &_e) {
25494         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25495         return 0;
25496       }
25497
25498     } CALL_CATCH_EXCEPTION(0);
25499   }
25500
25501   jresult = *result;
25502   return jresult;
25503 }
25504
25505
25506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
25507   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25508   int arg2 ;
25509   unsigned int *arg3 = 0 ;
25510   unsigned int temp3 ;
25511
25512   arg1 = (std::vector< unsigned int > *)jarg1;
25513   arg2 = (int)jarg2;
25514   temp3 = (unsigned int)jarg3;
25515   arg3 = &temp3;
25516   {
25517     try {
25518       try {
25519         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
25520       }
25521       catch(std::out_of_range &_e) {
25522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25523         return ;
25524       }
25525
25526     } CALL_CATCH_EXCEPTION();
25527   }
25528
25529 }
25530
25531
25532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
25533   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25534   std::vector< unsigned int > *arg2 = 0 ;
25535
25536   arg1 = (std::vector< unsigned int > *)jarg1;
25537   arg2 = (std::vector< unsigned int > *)jarg2;
25538   if (!arg2) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25540     return ;
25541   }
25542   {
25543     try {
25544       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
25545     } CALL_CATCH_EXCEPTION();
25546   }
25547
25548 }
25549
25550
25551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
25552   void * jresult ;
25553   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25554   int arg2 ;
25555   int arg3 ;
25556   std::vector< unsigned int > *result = 0 ;
25557
25558   arg1 = (std::vector< unsigned int > *)jarg1;
25559   arg2 = (int)jarg2;
25560   arg3 = (int)jarg3;
25561   {
25562     try {
25563       try {
25564         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
25565       }
25566       catch(std::out_of_range &_e) {
25567         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25568         return 0;
25569       }
25570       catch(std::invalid_argument &_e) {
25571         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
25572         return 0;
25573       }
25574
25575     } CALL_CATCH_EXCEPTION(0);
25576   }
25577
25578   jresult = (void *)result;
25579   return jresult;
25580 }
25581
25582
25583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
25584   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25585   int arg2 ;
25586   unsigned int *arg3 = 0 ;
25587   unsigned int temp3 ;
25588
25589   arg1 = (std::vector< unsigned int > *)jarg1;
25590   arg2 = (int)jarg2;
25591   temp3 = (unsigned int)jarg3;
25592   arg3 = &temp3;
25593   {
25594     try {
25595       try {
25596         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
25597       }
25598       catch(std::out_of_range &_e) {
25599         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25600         return ;
25601       }
25602
25603     } CALL_CATCH_EXCEPTION();
25604   }
25605
25606 }
25607
25608
25609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
25610   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25611   int arg2 ;
25612   std::vector< unsigned int > *arg3 = 0 ;
25613
25614   arg1 = (std::vector< unsigned int > *)jarg1;
25615   arg2 = (int)jarg2;
25616   arg3 = (std::vector< unsigned int > *)jarg3;
25617   if (!arg3) {
25618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25619     return ;
25620   }
25621   {
25622     try {
25623       try {
25624         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
25625       }
25626       catch(std::out_of_range &_e) {
25627         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25628         return ;
25629       }
25630
25631     } CALL_CATCH_EXCEPTION();
25632   }
25633
25634 }
25635
25636
25637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
25638   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25639   int arg2 ;
25640
25641   arg1 = (std::vector< unsigned int > *)jarg1;
25642   arg2 = (int)jarg2;
25643   {
25644     try {
25645       try {
25646         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
25647       }
25648       catch(std::out_of_range &_e) {
25649         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25650         return ;
25651       }
25652
25653     } CALL_CATCH_EXCEPTION();
25654   }
25655
25656 }
25657
25658
25659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
25660   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25661   int arg2 ;
25662   int arg3 ;
25663
25664   arg1 = (std::vector< unsigned int > *)jarg1;
25665   arg2 = (int)jarg2;
25666   arg3 = (int)jarg3;
25667   {
25668     try {
25669       try {
25670         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
25671       }
25672       catch(std::out_of_range &_e) {
25673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25674         return ;
25675       }
25676       catch(std::invalid_argument &_e) {
25677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
25678         return ;
25679       }
25680
25681     } CALL_CATCH_EXCEPTION();
25682   }
25683
25684 }
25685
25686
25687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
25688   void * jresult ;
25689   unsigned int *arg1 = 0 ;
25690   int arg2 ;
25691   unsigned int temp1 ;
25692   std::vector< unsigned int > *result = 0 ;
25693
25694   temp1 = (unsigned int)jarg1;
25695   arg1 = &temp1;
25696   arg2 = (int)jarg2;
25697   {
25698     try {
25699       try {
25700         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
25701       }
25702       catch(std::out_of_range &_e) {
25703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25704         return 0;
25705       }
25706
25707     } CALL_CATCH_EXCEPTION(0);
25708   }
25709
25710   jresult = (void *)result;
25711   return jresult;
25712 }
25713
25714
25715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
25716   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25717
25718   arg1 = (std::vector< unsigned int > *)jarg1;
25719   {
25720     try {
25721       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
25722     } CALL_CATCH_EXCEPTION();
25723   }
25724
25725 }
25726
25727
25728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
25729   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25730   int arg2 ;
25731   int arg3 ;
25732
25733   arg1 = (std::vector< unsigned int > *)jarg1;
25734   arg2 = (int)jarg2;
25735   arg3 = (int)jarg3;
25736   {
25737     try {
25738       try {
25739         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
25740       }
25741       catch(std::out_of_range &_e) {
25742         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25743         return ;
25744       }
25745       catch(std::invalid_argument &_e) {
25746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
25747         return ;
25748       }
25749
25750     } CALL_CATCH_EXCEPTION();
25751   }
25752
25753 }
25754
25755
25756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
25757   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25758   int arg2 ;
25759   std::vector< unsigned int > *arg3 = 0 ;
25760
25761   arg1 = (std::vector< unsigned int > *)jarg1;
25762   arg2 = (int)jarg2;
25763   arg3 = (std::vector< unsigned int > *)jarg3;
25764   if (!arg3) {
25765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
25766     return ;
25767   }
25768   {
25769     try {
25770       try {
25771         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
25772       }
25773       catch(std::out_of_range &_e) {
25774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
25775         return ;
25776       }
25777
25778     } CALL_CATCH_EXCEPTION();
25779   }
25780
25781 }
25782
25783
25784 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
25785   bool jresult ;
25786   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25787   unsigned int *arg2 = 0 ;
25788   unsigned int temp2 ;
25789   bool result;
25790
25791   arg1 = (std::vector< unsigned int > *)jarg1;
25792   temp2 = (unsigned int)jarg2;
25793   arg2 = &temp2;
25794   {
25795     try {
25796       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
25797     } CALL_CATCH_EXCEPTION(0);
25798   }
25799
25800   jresult = result;
25801   return jresult;
25802 }
25803
25804
25805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
25806   int jresult ;
25807   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25808   unsigned int *arg2 = 0 ;
25809   unsigned int temp2 ;
25810   int result;
25811
25812   arg1 = (std::vector< unsigned int > *)jarg1;
25813   temp2 = (unsigned int)jarg2;
25814   arg2 = &temp2;
25815   {
25816     try {
25817       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
25818     } CALL_CATCH_EXCEPTION(0);
25819   }
25820
25821   jresult = result;
25822   return jresult;
25823 }
25824
25825
25826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
25827   int jresult ;
25828   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25829   unsigned int *arg2 = 0 ;
25830   unsigned int temp2 ;
25831   int result;
25832
25833   arg1 = (std::vector< unsigned int > *)jarg1;
25834   temp2 = (unsigned int)jarg2;
25835   arg2 = &temp2;
25836   {
25837     try {
25838       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
25839     } CALL_CATCH_EXCEPTION(0);
25840   }
25841
25842   jresult = result;
25843   return jresult;
25844 }
25845
25846
25847 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
25848   bool jresult ;
25849   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25850   unsigned int *arg2 = 0 ;
25851   unsigned int temp2 ;
25852   bool result;
25853
25854   arg1 = (std::vector< unsigned int > *)jarg1;
25855   temp2 = (unsigned int)jarg2;
25856   arg2 = &temp2;
25857   {
25858     try {
25859       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
25860     } CALL_CATCH_EXCEPTION(0);
25861   }
25862
25863   jresult = result;
25864   return jresult;
25865 }
25866
25867
25868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
25869   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
25870
25871   arg1 = (std::vector< unsigned int > *)jarg1;
25872   {
25873     try {
25874       delete arg1;
25875     } CALL_CATCH_EXCEPTION();
25876   }
25877
25878 }
25879
25880
25881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
25882   void * jresult ;
25883   std::pair< unsigned int,Dali::Actor > *result = 0 ;
25884
25885   {
25886     try {
25887       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
25888     } CALL_CATCH_EXCEPTION(0);
25889   }
25890
25891   jresult = (void *)result;
25892   return jresult;
25893 }
25894
25895
25896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
25897   void * jresult ;
25898   unsigned int arg1 ;
25899   Dali::Actor arg2 ;
25900   Dali::Actor *argp2 ;
25901   std::pair< unsigned int,Dali::Actor > *result = 0 ;
25902
25903   arg1 = (unsigned int)jarg1;
25904   argp2 = (Dali::Actor *)jarg2;
25905   if (!argp2) {
25906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25907     return 0;
25908   }
25909   arg2 = *argp2;
25910   {
25911     try {
25912       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
25913     } CALL_CATCH_EXCEPTION(0);
25914   }
25915
25916   jresult = (void *)result;
25917   return jresult;
25918 }
25919
25920
25921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
25922   void * jresult ;
25923   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
25924   std::pair< unsigned int,Dali::Actor > *result = 0 ;
25925
25926   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
25927   if (!arg1) {
25928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
25929     return 0;
25930   }
25931   {
25932     try {
25933       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
25934     } CALL_CATCH_EXCEPTION(0);
25935   }
25936
25937   jresult = (void *)result;
25938   return jresult;
25939 }
25940
25941
25942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
25943   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
25944   unsigned int arg2 ;
25945
25946   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
25947   arg2 = (unsigned int)jarg2;
25948   if (arg1) (arg1)->first = arg2;
25949 }
25950
25951
25952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
25953   unsigned int jresult ;
25954   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
25955   unsigned int result;
25956
25957   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
25958   result = (unsigned int) ((arg1)->first);
25959   jresult = result;
25960   return jresult;
25961 }
25962
25963
25964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
25965   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
25966   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
25967
25968   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
25969   arg2 = (Dali::Actor *)jarg2;
25970   if (arg1) (arg1)->second = *arg2;
25971 }
25972
25973
25974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
25975   void * jresult ;
25976   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
25977   Dali::Actor *result = 0 ;
25978
25979   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
25980   result = (Dali::Actor *)& ((arg1)->second);
25981   jresult = (void *)result;
25982   return jresult;
25983 }
25984
25985
25986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
25987   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
25988
25989   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
25990   {
25991     try {
25992       delete arg1;
25993     } CALL_CATCH_EXCEPTION();
25994   }
25995
25996 }
25997
25998
25999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
26000   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26001
26002   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26003   {
26004     try {
26005       (arg1)->clear();
26006     } CALL_CATCH_EXCEPTION();
26007   }
26008
26009 }
26010
26011
26012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
26013   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26014   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
26015
26016   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26017   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
26018   if (!arg2) {
26019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26020     return ;
26021   }
26022   {
26023     try {
26024       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
26025     } CALL_CATCH_EXCEPTION();
26026   }
26027
26028 }
26029
26030
26031 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
26032   unsigned long jresult ;
26033   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26034   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
26035
26036   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26037   {
26038     try {
26039       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
26040     } CALL_CATCH_EXCEPTION(0);
26041   }
26042
26043   jresult = (unsigned long)result;
26044   return jresult;
26045 }
26046
26047
26048 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
26049   unsigned long jresult ;
26050   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26051   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
26052
26053   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26054   {
26055     try {
26056       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
26057     } CALL_CATCH_EXCEPTION(0);
26058   }
26059
26060   jresult = (unsigned long)result;
26061   return jresult;
26062 }
26063
26064
26065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
26066   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26067   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
26068
26069   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26070   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
26071   {
26072     try {
26073       (arg1)->reserve(arg2);
26074     } CALL_CATCH_EXCEPTION();
26075   }
26076
26077 }
26078
26079
26080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
26081   void * jresult ;
26082   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26083
26084   {
26085     try {
26086       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
26087     } CALL_CATCH_EXCEPTION(0);
26088   }
26089
26090   jresult = (void *)result;
26091   return jresult;
26092 }
26093
26094
26095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
26096   void * jresult ;
26097   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
26098   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26099
26100   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26101   if (!arg1) {
26102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26103     return 0;
26104   }
26105   {
26106     try {
26107       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);
26108     } CALL_CATCH_EXCEPTION(0);
26109   }
26110
26111   jresult = (void *)result;
26112   return jresult;
26113 }
26114
26115
26116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
26117   void * jresult ;
26118   int arg1 ;
26119   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26120
26121   arg1 = (int)jarg1;
26122   {
26123     try {
26124       try {
26125         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);
26126       }
26127       catch(std::out_of_range &_e) {
26128         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26129         return 0;
26130       }
26131
26132     } CALL_CATCH_EXCEPTION(0);
26133   }
26134
26135   jresult = (void *)result;
26136   return jresult;
26137 }
26138
26139
26140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
26141   void * jresult ;
26142   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26143   int arg2 ;
26144   std::pair< unsigned int,Dali::Actor > result;
26145
26146   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26147   arg2 = (int)jarg2;
26148   {
26149     try {
26150       try {
26151         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
26152       }
26153       catch(std::out_of_range &_e) {
26154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26155         return 0;
26156       }
26157
26158     } CALL_CATCH_EXCEPTION(0);
26159   }
26160
26161   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
26162   return jresult;
26163 }
26164
26165
26166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
26167   void * jresult ;
26168   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26169   int arg2 ;
26170   std::pair< unsigned int,Dali::Actor > *result = 0 ;
26171
26172   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26173   arg2 = (int)jarg2;
26174   {
26175     try {
26176       try {
26177         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
26178       }
26179       catch(std::out_of_range &_e) {
26180         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26181         return 0;
26182       }
26183
26184     } CALL_CATCH_EXCEPTION(0);
26185   }
26186
26187   jresult = (void *)result;
26188   return jresult;
26189 }
26190
26191
26192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
26193   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26194   int arg2 ;
26195   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
26196
26197   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26198   arg2 = (int)jarg2;
26199   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
26200   if (!arg3) {
26201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26202     return ;
26203   }
26204   {
26205     try {
26206       try {
26207         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);
26208       }
26209       catch(std::out_of_range &_e) {
26210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26211         return ;
26212       }
26213
26214     } CALL_CATCH_EXCEPTION();
26215   }
26216
26217 }
26218
26219
26220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
26221   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26222   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
26223
26224   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26225   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
26226   if (!arg2) {
26227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26228     return ;
26229   }
26230   {
26231     try {
26232       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);
26233     } CALL_CATCH_EXCEPTION();
26234   }
26235
26236 }
26237
26238
26239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
26240   void * jresult ;
26241   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26242   int arg2 ;
26243   int arg3 ;
26244   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26245
26246   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26247   arg2 = (int)jarg2;
26248   arg3 = (int)jarg3;
26249   {
26250     try {
26251       try {
26252         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);
26253       }
26254       catch(std::out_of_range &_e) {
26255         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26256         return 0;
26257       }
26258       catch(std::invalid_argument &_e) {
26259         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26260         return 0;
26261       }
26262
26263     } CALL_CATCH_EXCEPTION(0);
26264   }
26265
26266   jresult = (void *)result;
26267   return jresult;
26268 }
26269
26270
26271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
26272   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26273   int arg2 ;
26274   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
26275
26276   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26277   arg2 = (int)jarg2;
26278   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
26279   if (!arg3) {
26280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26281     return ;
26282   }
26283   {
26284     try {
26285       try {
26286         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);
26287       }
26288       catch(std::out_of_range &_e) {
26289         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26290         return ;
26291       }
26292
26293     } CALL_CATCH_EXCEPTION();
26294   }
26295
26296 }
26297
26298
26299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26300   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26301   int arg2 ;
26302   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
26303
26304   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26305   arg2 = (int)jarg2;
26306   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
26307   if (!arg3) {
26308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26309     return ;
26310   }
26311   {
26312     try {
26313       try {
26314         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);
26315       }
26316       catch(std::out_of_range &_e) {
26317         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26318         return ;
26319       }
26320
26321     } CALL_CATCH_EXCEPTION();
26322   }
26323
26324 }
26325
26326
26327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
26328   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26329   int arg2 ;
26330
26331   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26332   arg2 = (int)jarg2;
26333   {
26334     try {
26335       try {
26336         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
26337       }
26338       catch(std::out_of_range &_e) {
26339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26340         return ;
26341       }
26342
26343     } CALL_CATCH_EXCEPTION();
26344   }
26345
26346 }
26347
26348
26349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26350   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26351   int arg2 ;
26352   int arg3 ;
26353
26354   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26355   arg2 = (int)jarg2;
26356   arg3 = (int)jarg3;
26357   {
26358     try {
26359       try {
26360         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
26361       }
26362       catch(std::out_of_range &_e) {
26363         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26364         return ;
26365       }
26366       catch(std::invalid_argument &_e) {
26367         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26368         return ;
26369       }
26370
26371     } CALL_CATCH_EXCEPTION();
26372   }
26373
26374 }
26375
26376
26377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
26378   void * jresult ;
26379   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
26380   int arg2 ;
26381   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
26382
26383   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
26384   if (!arg1) {
26385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
26386     return 0;
26387   }
26388   arg2 = (int)jarg2;
26389   {
26390     try {
26391       try {
26392         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);
26393       }
26394       catch(std::out_of_range &_e) {
26395         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26396         return 0;
26397       }
26398
26399     } CALL_CATCH_EXCEPTION(0);
26400   }
26401
26402   jresult = (void *)result;
26403   return jresult;
26404 }
26405
26406
26407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
26408   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26409
26410   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26411   {
26412     try {
26413       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
26414     } CALL_CATCH_EXCEPTION();
26415   }
26416
26417 }
26418
26419
26420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26421   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26422   int arg2 ;
26423   int arg3 ;
26424
26425   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26426   arg2 = (int)jarg2;
26427   arg3 = (int)jarg3;
26428   {
26429     try {
26430       try {
26431         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26432       }
26433       catch(std::out_of_range &_e) {
26434         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26435         return ;
26436       }
26437       catch(std::invalid_argument &_e) {
26438         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26439         return ;
26440       }
26441
26442     } CALL_CATCH_EXCEPTION();
26443   }
26444
26445 }
26446
26447
26448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26449   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26450   int arg2 ;
26451   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
26452
26453   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26454   arg2 = (int)jarg2;
26455   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
26456   if (!arg3) {
26457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
26458     return ;
26459   }
26460   {
26461     try {
26462       try {
26463         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);
26464       }
26465       catch(std::out_of_range &_e) {
26466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26467         return ;
26468       }
26469
26470     } CALL_CATCH_EXCEPTION();
26471   }
26472
26473 }
26474
26475
26476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
26477   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
26478
26479   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
26480   {
26481     try {
26482       delete arg1;
26483     } CALL_CATCH_EXCEPTION();
26484   }
26485
26486 }
26487
26488
26489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
26490   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26491
26492   arg1 = (std::vector< Dali::Actor > *)jarg1;
26493   {
26494     try {
26495       (arg1)->clear();
26496     } CALL_CATCH_EXCEPTION();
26497   }
26498
26499 }
26500
26501
26502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
26503   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26504   Dali::Actor *arg2 = 0 ;
26505
26506   arg1 = (std::vector< Dali::Actor > *)jarg1;
26507   arg2 = (Dali::Actor *)jarg2;
26508   if (!arg2) {
26509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26510     return ;
26511   }
26512   {
26513     try {
26514       (arg1)->push_back((Dali::Actor const &)*arg2);
26515     } CALL_CATCH_EXCEPTION();
26516   }
26517
26518 }
26519
26520
26521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
26522   unsigned long jresult ;
26523   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26524   std::vector< Dali::Actor >::size_type result;
26525
26526   arg1 = (std::vector< Dali::Actor > *)jarg1;
26527   {
26528     try {
26529       result = ((std::vector< Dali::Actor > const *)arg1)->size();
26530     } CALL_CATCH_EXCEPTION(0);
26531   }
26532
26533   jresult = (unsigned long)result;
26534   return jresult;
26535 }
26536
26537
26538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
26539   unsigned long jresult ;
26540   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26541   std::vector< Dali::Actor >::size_type result;
26542
26543   arg1 = (std::vector< Dali::Actor > *)jarg1;
26544   {
26545     try {
26546       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
26547     } CALL_CATCH_EXCEPTION(0);
26548   }
26549
26550   jresult = (unsigned long)result;
26551   return jresult;
26552 }
26553
26554
26555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
26556   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26557   std::vector< Dali::Actor >::size_type arg2 ;
26558
26559   arg1 = (std::vector< Dali::Actor > *)jarg1;
26560   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
26561   {
26562     try {
26563       (arg1)->reserve(arg2);
26564     } CALL_CATCH_EXCEPTION();
26565   }
26566
26567 }
26568
26569
26570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
26571   void * jresult ;
26572   std::vector< Dali::Actor > *result = 0 ;
26573
26574   {
26575     try {
26576       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
26577     } CALL_CATCH_EXCEPTION(0);
26578   }
26579
26580   jresult = (void *)result;
26581   return jresult;
26582 }
26583
26584
26585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
26586   void * jresult ;
26587   std::vector< Dali::Actor > *arg1 = 0 ;
26588   std::vector< Dali::Actor > *result = 0 ;
26589
26590   arg1 = (std::vector< Dali::Actor > *)jarg1;
26591   if (!arg1) {
26592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
26593     return 0;
26594   }
26595   {
26596     try {
26597       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
26598     } CALL_CATCH_EXCEPTION(0);
26599   }
26600
26601   jresult = (void *)result;
26602   return jresult;
26603 }
26604
26605
26606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
26607   void * jresult ;
26608   int arg1 ;
26609   std::vector< Dali::Actor > *result = 0 ;
26610
26611   arg1 = (int)jarg1;
26612   {
26613     try {
26614       try {
26615         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
26616       }
26617       catch(std::out_of_range &_e) {
26618         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26619         return 0;
26620       }
26621
26622     } CALL_CATCH_EXCEPTION(0);
26623   }
26624
26625   jresult = (void *)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
26631   void * jresult ;
26632   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26633   int arg2 ;
26634   Dali::Actor result;
26635
26636   arg1 = (std::vector< Dali::Actor > *)jarg1;
26637   arg2 = (int)jarg2;
26638   {
26639     try {
26640       try {
26641         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
26642       }
26643       catch(std::out_of_range &_e) {
26644         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26645         return 0;
26646       }
26647
26648     } CALL_CATCH_EXCEPTION(0);
26649   }
26650
26651   jresult = new Dali::Actor((const Dali::Actor &)result);
26652   return jresult;
26653 }
26654
26655
26656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
26657   void * jresult ;
26658   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26659   int arg2 ;
26660   Dali::Actor *result = 0 ;
26661
26662   arg1 = (std::vector< Dali::Actor > *)jarg1;
26663   arg2 = (int)jarg2;
26664   {
26665     try {
26666       try {
26667         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
26668       }
26669       catch(std::out_of_range &_e) {
26670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26671         return 0;
26672       }
26673
26674     } CALL_CATCH_EXCEPTION(0);
26675   }
26676
26677   jresult = (void *)result;
26678   return jresult;
26679 }
26680
26681
26682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
26683   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26684   int arg2 ;
26685   Dali::Actor *arg3 = 0 ;
26686
26687   arg1 = (std::vector< Dali::Actor > *)jarg1;
26688   arg2 = (int)jarg2;
26689   arg3 = (Dali::Actor *)jarg3;
26690   if (!arg3) {
26691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26692     return ;
26693   }
26694   {
26695     try {
26696       try {
26697         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
26698       }
26699       catch(std::out_of_range &_e) {
26700         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26701         return ;
26702       }
26703
26704     } CALL_CATCH_EXCEPTION();
26705   }
26706
26707 }
26708
26709
26710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
26711   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26712   std::vector< Dali::Actor > *arg2 = 0 ;
26713
26714   arg1 = (std::vector< Dali::Actor > *)jarg1;
26715   arg2 = (std::vector< Dali::Actor > *)jarg2;
26716   if (!arg2) {
26717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
26718     return ;
26719   }
26720   {
26721     try {
26722       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
26723     } CALL_CATCH_EXCEPTION();
26724   }
26725
26726 }
26727
26728
26729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
26730   void * jresult ;
26731   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26732   int arg2 ;
26733   int arg3 ;
26734   std::vector< Dali::Actor > *result = 0 ;
26735
26736   arg1 = (std::vector< Dali::Actor > *)jarg1;
26737   arg2 = (int)jarg2;
26738   arg3 = (int)jarg3;
26739   {
26740     try {
26741       try {
26742         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
26743       }
26744       catch(std::out_of_range &_e) {
26745         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26746         return 0;
26747       }
26748       catch(std::invalid_argument &_e) {
26749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26750         return 0;
26751       }
26752
26753     } CALL_CATCH_EXCEPTION(0);
26754   }
26755
26756   jresult = (void *)result;
26757   return jresult;
26758 }
26759
26760
26761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
26762   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26763   int arg2 ;
26764   Dali::Actor *arg3 = 0 ;
26765
26766   arg1 = (std::vector< Dali::Actor > *)jarg1;
26767   arg2 = (int)jarg2;
26768   arg3 = (Dali::Actor *)jarg3;
26769   if (!arg3) {
26770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26771     return ;
26772   }
26773   {
26774     try {
26775       try {
26776         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
26777       }
26778       catch(std::out_of_range &_e) {
26779         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26780         return ;
26781       }
26782
26783     } CALL_CATCH_EXCEPTION();
26784   }
26785
26786 }
26787
26788
26789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
26790   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26791   int arg2 ;
26792   std::vector< Dali::Actor > *arg3 = 0 ;
26793
26794   arg1 = (std::vector< Dali::Actor > *)jarg1;
26795   arg2 = (int)jarg2;
26796   arg3 = (std::vector< Dali::Actor > *)jarg3;
26797   if (!arg3) {
26798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
26799     return ;
26800   }
26801   {
26802     try {
26803       try {
26804         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
26805       }
26806       catch(std::out_of_range &_e) {
26807         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26808         return ;
26809       }
26810
26811     } CALL_CATCH_EXCEPTION();
26812   }
26813
26814 }
26815
26816
26817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
26818   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26819   int arg2 ;
26820
26821   arg1 = (std::vector< Dali::Actor > *)jarg1;
26822   arg2 = (int)jarg2;
26823   {
26824     try {
26825       try {
26826         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
26827       }
26828       catch(std::out_of_range &_e) {
26829         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26830         return ;
26831       }
26832
26833     } CALL_CATCH_EXCEPTION();
26834   }
26835
26836 }
26837
26838
26839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
26840   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26841   int arg2 ;
26842   int arg3 ;
26843
26844   arg1 = (std::vector< Dali::Actor > *)jarg1;
26845   arg2 = (int)jarg2;
26846   arg3 = (int)jarg3;
26847   {
26848     try {
26849       try {
26850         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
26851       }
26852       catch(std::out_of_range &_e) {
26853         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26854         return ;
26855       }
26856       catch(std::invalid_argument &_e) {
26857         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26858         return ;
26859       }
26860
26861     } CALL_CATCH_EXCEPTION();
26862   }
26863
26864 }
26865
26866
26867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
26868   void * jresult ;
26869   Dali::Actor *arg1 = 0 ;
26870   int arg2 ;
26871   std::vector< Dali::Actor > *result = 0 ;
26872
26873   arg1 = (Dali::Actor *)jarg1;
26874   if (!arg1) {
26875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
26876     return 0;
26877   }
26878   arg2 = (int)jarg2;
26879   {
26880     try {
26881       try {
26882         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
26883       }
26884       catch(std::out_of_range &_e) {
26885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26886         return 0;
26887       }
26888
26889     } CALL_CATCH_EXCEPTION(0);
26890   }
26891
26892   jresult = (void *)result;
26893   return jresult;
26894 }
26895
26896
26897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
26898   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26899
26900   arg1 = (std::vector< Dali::Actor > *)jarg1;
26901   {
26902     try {
26903       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
26904     } CALL_CATCH_EXCEPTION();
26905   }
26906
26907 }
26908
26909
26910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
26911   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26912   int arg2 ;
26913   int arg3 ;
26914
26915   arg1 = (std::vector< Dali::Actor > *)jarg1;
26916   arg2 = (int)jarg2;
26917   arg3 = (int)jarg3;
26918   {
26919     try {
26920       try {
26921         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
26922       }
26923       catch(std::out_of_range &_e) {
26924         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26925         return ;
26926       }
26927       catch(std::invalid_argument &_e) {
26928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
26929         return ;
26930       }
26931
26932     } CALL_CATCH_EXCEPTION();
26933   }
26934
26935 }
26936
26937
26938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
26939   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26940   int arg2 ;
26941   std::vector< Dali::Actor > *arg3 = 0 ;
26942
26943   arg1 = (std::vector< Dali::Actor > *)jarg1;
26944   arg2 = (int)jarg2;
26945   arg3 = (std::vector< Dali::Actor > *)jarg3;
26946   if (!arg3) {
26947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
26948     return ;
26949   }
26950   {
26951     try {
26952       try {
26953         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
26954       }
26955       catch(std::out_of_range &_e) {
26956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
26957         return ;
26958       }
26959
26960     } CALL_CATCH_EXCEPTION();
26961   }
26962
26963 }
26964
26965
26966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
26967   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
26968
26969   arg1 = (std::vector< Dali::Actor > *)jarg1;
26970   {
26971     try {
26972       delete arg1;
26973     } CALL_CATCH_EXCEPTION();
26974   }
26975
26976 }
26977
26978
26979 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
26980   bool jresult ;
26981   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
26982   bool result;
26983
26984   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
26985   {
26986     try {
26987       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
26988     } CALL_CATCH_EXCEPTION(0);
26989   }
26990
26991   jresult = result;
26992   return jresult;
26993 }
26994
26995
26996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
26997   unsigned long jresult ;
26998   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
26999   std::size_t result;
27000
27001   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27002   {
27003     try {
27004       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
27005     } CALL_CATCH_EXCEPTION(0);
27006   }
27007
27008   jresult = (unsigned long)result;
27009   return jresult;
27010 }
27011
27012
27013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
27014   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27015   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
27016
27017   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27018   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
27019   {
27020     try {
27021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
27022     } CALL_CATCH_EXCEPTION();
27023   }
27024
27025 }
27026
27027
27028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
27029   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27030   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
27031
27032   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27033   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
27034   {
27035     try {
27036       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
27037     } CALL_CATCH_EXCEPTION();
27038   }
27039
27040 }
27041
27042
27043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
27044   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27045   Dali::Actor arg2 ;
27046   Dali::Actor arg3 ;
27047   Dali::Actor *argp2 ;
27048   Dali::Actor *argp3 ;
27049
27050   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27051   argp2 = (Dali::Actor *)jarg2;
27052   if (!argp2) {
27053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27054     return ;
27055   }
27056   arg2 = *argp2;
27057   argp3 = (Dali::Actor *)jarg3;
27058   if (!argp3) {
27059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27060     return ;
27061   }
27062   arg3 = *argp3;
27063   {
27064     try {
27065       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
27066     } CALL_CATCH_EXCEPTION();
27067   }
27068
27069 }
27070
27071
27072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
27073   void * jresult ;
27074   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
27075
27076   {
27077     try {
27078       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
27079     } CALL_CATCH_EXCEPTION(0);
27080   }
27081
27082   jresult = (void *)result;
27083   return jresult;
27084 }
27085
27086
27087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
27088   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
27089
27090   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
27091   {
27092     try {
27093       delete arg1;
27094     } CALL_CATCH_EXCEPTION();
27095   }
27096
27097 }
27098
27099
27100 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
27101   bool jresult ;
27102   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27103   bool result;
27104
27105   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27106   {
27107     try {
27108       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
27109     } CALL_CATCH_EXCEPTION(0);
27110   }
27111
27112   jresult = result;
27113   return jresult;
27114 }
27115
27116
27117 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
27118   unsigned long jresult ;
27119   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27120   std::size_t result;
27121
27122   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27123   {
27124     try {
27125       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
27126     } CALL_CATCH_EXCEPTION(0);
27127   }
27128
27129   jresult = (unsigned long)result;
27130   return jresult;
27131 }
27132
27133
27134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
27135   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27136   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
27137
27138   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27139   arg2 = (void (*)(Dali::Actor,bool))jarg2;
27140   {
27141     try {
27142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
27143     } CALL_CATCH_EXCEPTION();
27144   }
27145
27146 }
27147
27148
27149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
27150   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27151   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
27152
27153   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27154   arg2 = (void (*)(Dali::Actor,bool))jarg2;
27155   {
27156     try {
27157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
27158     } CALL_CATCH_EXCEPTION();
27159   }
27160
27161 }
27162
27163
27164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, bool jarg3) {
27165   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27166   Dali::Actor arg2 ;
27167   bool arg3 ;
27168   Dali::Actor *argp2 ;
27169
27170   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27171   argp2 = (Dali::Actor *)jarg2;
27172   if (!argp2) {
27173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
27174     return ;
27175   }
27176   arg2 = *argp2;
27177   arg3 = jarg3 ? true : false;
27178   {
27179     try {
27180       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
27181     } CALL_CATCH_EXCEPTION();
27182   }
27183
27184 }
27185
27186
27187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
27188   void * jresult ;
27189   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
27190
27191   {
27192     try {
27193       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
27194     } CALL_CATCH_EXCEPTION(0);
27195   }
27196
27197   jresult = (void *)result;
27198   return jresult;
27199 }
27200
27201
27202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
27203   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
27204
27205   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
27206   {
27207     try {
27208       delete arg1;
27209     } CALL_CATCH_EXCEPTION();
27210   }
27211
27212 }
27213
27214
27215 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_GenerateUrl(void* handle)
27216 {
27217   Dali::Toolkit::ImageUrl result;
27218   NativeImageSource* nativeImageSource = (NativeImageSource*)handle;
27219   void *jresult;
27220
27221   if (!nativeImageSource)
27222   {
27223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "some argument is null", 0);
27224     return 0;
27225   }
27226   {
27227     try
27228     {
27229       result = Dali::Toolkit::Image::GenerateUrl(nativeImageSource);
27230     }
27231     catch (std::out_of_range& e)
27232     {
27233       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27234       return 0;
27235     }
27236     catch (std::exception& e)
27237     {
27238       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27239       return 0;
27240     }
27241     catch (Dali::DaliException e)
27242     {
27243       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27244       return 0;
27245     }
27246     catch (...)
27247     {
27248       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27249       return 0;
27250     }
27251   }
27252
27253   jresult = new Dali::Toolkit::ImageUrl((const Dali::Toolkit::ImageUrl &)result);
27254   return jresult;
27255 }
27256
27257
27258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageUrl(void* jarg1)
27259 {
27260   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
27261
27262   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
27263   {
27264     try
27265     {
27266       delete imageUrl;
27267     }
27268     catch (std::out_of_range& e)
27269     {
27270       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27271       return;
27272     }
27273     catch (std::exception& e)
27274     {
27275       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27276       return;
27277     }
27278     catch (Dali::DaliException e)
27279     {
27280       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27281       return;
27282     }
27283     catch (...)
27284     {
27285       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27286       return;
27287     }
27288   }
27289 }
27290
27291 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImageUrl_Get(void* jarg1)
27292 {
27293   char *jresult;
27294   Dali::Toolkit::ImageUrl* imageUrl = (Dali::Toolkit::ImageUrl*) 0;
27295   std::string result;
27296
27297   imageUrl = (Dali::Toolkit::ImageUrl*)jarg1;
27298   {
27299     try
27300     {
27301       result = imageUrl->GetUrl();
27302     }
27303     catch (std::out_of_range& e)
27304     {
27305       SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
27306       return 0;
27307     }
27308     catch (std::exception& e)
27309     {
27310       SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
27311       return 0;
27312     }
27313     catch (Dali::DaliException e)
27314     {
27315       SWIG_CSharpException(SWIG_UnknownError, e.condition);
27316       return 0;
27317     }
27318     catch (...)
27319     {
27320       SWIG_CSharpException(SWIG_UnknownError, "unknown error");
27321       return 0;
27322     }
27323   }
27324
27325   jresult = SWIG_csharp_string_callback((&result)->c_str());
27326   return jresult;
27327 }
27328
27329
27330 // TODO : SwigDirector_ViewImpl
27331
27332
27333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
27334   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27335   int arg2 ;
27336   SwigDirector_ViewImpl *darg = 0;
27337
27338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27339   arg2 = (int)jarg2;
27340   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27341   if(!darg) {
27342     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27343     return;
27344   }
27345   {
27346     try {
27347       if(darg) {
27348         (darg)->OnSceneConnection(arg2);
27349       }
27350     } CALL_CATCH_EXCEPTION();
27351   }
27352
27353 }
27354
27355
27356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
27357   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27358   int arg2 ;
27359   SwigDirector_ViewImpl *darg = 0;
27360
27361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27362   arg2 = (int)jarg2;
27363   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27364   if(!darg) {
27365     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27366     return;
27367   }
27368   {
27369     try {
27370       if(darg) {
27371         (darg)->OnSceneConnectionSwigPublic(arg2);
27372       }
27373     } CALL_CATCH_EXCEPTION();
27374   }
27375
27376 }
27377
27378
27379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
27380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27381   SwigDirector_ViewImpl *darg = 0;
27382
27383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27384   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27385   if(!darg) {
27386     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27387     return;
27388   }
27389   {
27390     try {
27391       if(darg) {
27392         (darg)->OnSceneDisconnection();
27393       }
27394     } CALL_CATCH_EXCEPTION();
27395   }
27396
27397 }
27398
27399
27400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
27401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27402   SwigDirector_ViewImpl *darg = 0;
27403
27404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27405   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27406   if(!darg) {
27407     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27408     return;
27409   }
27410   {
27411     try {
27412       if(darg) {
27413         (darg)->OnSceneDisconnectionSwigPublic();
27414       }
27415     } CALL_CATCH_EXCEPTION();
27416   }
27417
27418 }
27419
27420
27421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
27422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27423   Dali::Actor *arg2 = 0 ;
27424   SwigDirector_ViewImpl *darg = 0;
27425
27426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27427   arg2 = (Dali::Actor *)jarg2;
27428   if (!arg2) {
27429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27430     return ;
27431   }
27432   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27433   if(!darg) {
27434     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27435     return;
27436   }
27437   {
27438     try {
27439       if(darg) {
27440         (darg)->OnChildAdd(*arg2);
27441       }
27442     } CALL_CATCH_EXCEPTION();
27443   }
27444
27445 }
27446
27447
27448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27450   Dali::Actor *arg2 = 0 ;
27451   SwigDirector_ViewImpl *darg = 0;
27452
27453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27454   arg2 = (Dali::Actor *)jarg2;
27455   if (!arg2) {
27456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27457     return ;
27458   }
27459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27460   if(!darg) {
27461     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27462     return;
27463   }
27464   {
27465     try {
27466       if(darg) {
27467           (darg)->OnChildAddSwigPublic(*arg2);
27468       }
27469     } CALL_CATCH_EXCEPTION();
27470   }
27471
27472 }
27473
27474
27475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
27476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27477   Dali::Actor *arg2 = 0 ;
27478   SwigDirector_ViewImpl *darg = 0;
27479
27480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27481   arg2 = (Dali::Actor *)jarg2;
27482   if (!arg2) {
27483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27484     return ;
27485   }
27486   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27487   if(!darg) {
27488     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27489     return;
27490   }
27491   {
27492     try {
27493       if(darg) {
27494         (darg)->OnChildRemove(*arg2);
27495       }
27496     } CALL_CATCH_EXCEPTION();
27497   }
27498
27499 }
27500
27501
27502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27504   Dali::Actor *arg2 = 0 ;
27505   SwigDirector_ViewImpl *darg = 0;
27506
27507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27508   arg2 = (Dali::Actor *)jarg2;
27509   if (!arg2) {
27510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
27511     return ;
27512   }
27513   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27514   if(!darg) {
27515     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27516     return;
27517   }
27518   {
27519     try {
27520       if(darg) {
27521         (darg)->OnChildRemoveSwigPublic(*arg2);
27522       }
27523     } CALL_CATCH_EXCEPTION();
27524   }
27525
27526 }
27527
27528
27529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
27530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27531   Dali::Property::Index arg2 ;
27532   Dali::Property::Value arg3 ;
27533   Dali::Property::Value *argp3 ;
27534   SwigDirector_ViewImpl *darg = 0;
27535
27536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27537   arg2 = (Dali::Property::Index)jarg2;
27538   argp3 = (Dali::Property::Value *)jarg3;
27539   if (!argp3) {
27540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27541     return ;
27542   }
27543   arg3 = *argp3;
27544   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27545   if (!darg) {
27546     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27547     return;
27548   }
27549   {
27550     try {
27551       (darg)->OnPropertySet(arg2,arg3);
27552     } CALL_CATCH_EXCEPTION();
27553   }
27554
27555 }
27556
27557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
27558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27559   Dali::Property::Index arg2 ;
27560   Dali::Property::Value arg3 ;
27561   Dali::Property::Value *argp3 ;
27562   SwigDirector_ViewImpl *darg = 0;
27563
27564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27565   arg2 = (Dali::Property::Index)jarg2;
27566   argp3 = (Dali::Property::Value *)jarg3;
27567   if (!argp3) {
27568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
27569     return ;
27570   }
27571   arg3 = *argp3;
27572   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27573   if (!darg) {
27574     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27575     return;
27576   }
27577   {
27578     try {
27579       (darg)->OnPropertySetSwigPublic(arg2,arg3);
27580     } CALL_CATCH_EXCEPTION();
27581   }
27582
27583 }
27584
27585
27586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
27587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27588   Dali::Vector3 *arg2 = 0 ;
27589   SwigDirector_ViewImpl *darg = 0;
27590
27591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27592   arg2 = (Dali::Vector3 *)jarg2;
27593   if (!arg2) {
27594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27595     return ;
27596   }
27597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27598   if (!darg) {
27599     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27600     return;
27601   }
27602   {
27603     try {
27604       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
27605     } CALL_CATCH_EXCEPTION();
27606   }
27607
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27613   Dali::Vector3 *arg2 = 0 ;
27614   SwigDirector_ViewImpl *darg = 0;
27615
27616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27617   arg2 = (Dali::Vector3 *)jarg2;
27618   if (!arg2) {
27619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27620     return ;
27621   }
27622   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27623   if (!darg) {
27624     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27625     return;
27626   }
27627   {
27628     try {
27629       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
27630     } CALL_CATCH_EXCEPTION();
27631   }
27632
27633 }
27634
27635
27636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
27637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27638   Dali::Animation *arg2 = 0 ;
27639   Dali::Vector3 *arg3 = 0 ;
27640   SwigDirector_ViewImpl *darg = 0;
27641
27642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27643   arg2 = (Dali::Animation *)jarg2;
27644   if (!arg2) {
27645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
27646     return ;
27647   }
27648   arg3 = (Dali::Vector3 *)jarg3;
27649   if (!arg3) {
27650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27651     return ;
27652   }
27653   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27654   if (!darg) {
27655     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27656     return;
27657   }
27658   {
27659     try {
27660       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
27661     } CALL_CATCH_EXCEPTION();
27662   }
27663
27664 }
27665
27666
27667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
27668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27669   Dali::Animation *arg2 = 0 ;
27670   Dali::Vector3 *arg3 = 0 ;
27671   SwigDirector_ViewImpl *darg = 0;
27672
27673   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27674   arg2 = (Dali::Animation *)jarg2;
27675   if (!arg2) {
27676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
27677     return ;
27678   }
27679   arg3 = (Dali::Vector3 *)jarg3;
27680   if (!arg3) {
27681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
27682     return ;
27683   }
27684   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27685   if (!darg) {
27686     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27687     return;
27688   }
27689   {
27690     try {
27691       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
27692     } CALL_CATCH_EXCEPTION();
27693   }
27694 }
27695
27696 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
27697   bool jresult ;
27698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27699   Dali::KeyEvent *arg2 = 0 ;
27700   SwigDirector_ViewImpl *darg = 0;
27701   bool result;
27702
27703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27704   arg2 = (Dali::KeyEvent *)jarg2;
27705   if (!arg2) {
27706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27707     return 0;
27708   }
27709   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27710   if (!darg) {
27711     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27712     return 0;
27713   }
27714   {
27715     try {
27716       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
27717     } CALL_CATCH_EXCEPTION(0);
27718   }
27719
27720   jresult = result;
27721   return jresult;
27722 }
27723
27724
27725 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
27726   bool jresult ;
27727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27728   Dali::KeyEvent *arg2 = 0 ;
27729   SwigDirector_ViewImpl *darg = 0;
27730   bool result;
27731
27732   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27733   arg2 = (Dali::KeyEvent *)jarg2;
27734   if (!arg2) {
27735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27736     return 0;
27737   }
27738   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27739   if (!darg) {
27740     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27741     return 0;
27742   }
27743   {
27744     try {
27745       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
27746     } CALL_CATCH_EXCEPTION(0);
27747   }
27748
27749   jresult = result;
27750   return jresult;
27751 }
27752
27753
27754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
27755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27756   Dali::Vector2 *arg2 = 0 ;
27757   Dali::RelayoutContainer *arg3 = 0 ;
27758   SwigDirector_ViewImpl *darg = 0;
27759
27760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27761   arg2 = (Dali::Vector2 *)jarg2;
27762   if (!arg2) {
27763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27764     return ;
27765   }
27766   arg3 = (Dali::RelayoutContainer *)jarg3;
27767   if (!arg3) {
27768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
27769     return ;
27770   }
27771   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27772   if (!darg) {
27773     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27774     return;
27775   }
27776   {
27777     try {
27778       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
27779     } CALL_CATCH_EXCEPTION();
27780   }
27781
27782 }
27783
27784
27785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
27786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27787   Dali::Vector2 *arg2 = 0 ;
27788   Dali::RelayoutContainer *arg3 = 0 ;
27789   SwigDirector_ViewImpl *darg = 0;
27790
27791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27792   arg2 = (Dali::Vector2 *)jarg2;
27793   if (!arg2) {
27794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
27795     return ;
27796   }
27797   arg3 = (Dali::RelayoutContainer *)jarg3;
27798   if (!arg3) {
27799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
27800     return ;
27801   }
27802   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27803   if (!darg) {
27804     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27805     return;
27806   }
27807   {
27808     try {
27809       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
27810     } CALL_CATCH_EXCEPTION();
27811   }
27812
27813 }
27814
27815
27816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
27817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27818   Dali::ResizePolicy::Type arg2 ;
27819   Dali::Dimension::Type arg3 ;
27820   SwigDirector_ViewImpl *darg = 0;
27821
27822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27823   arg2 = (Dali::ResizePolicy::Type)jarg2;
27824   arg3 = (Dali::Dimension::Type)jarg3;
27825   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27826   if (!darg) {
27827     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27828     return;
27829   }
27830   {
27831     try {
27832       (darg)->OnSetResizePolicy(arg2,arg3);
27833     } CALL_CATCH_EXCEPTION();
27834   }
27835
27836 }
27837
27838
27839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
27840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27841   Dali::ResizePolicy::Type arg2 ;
27842   Dali::Dimension::Type arg3 ;
27843   SwigDirector_ViewImpl *darg = 0;
27844
27845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27846   arg2 = (Dali::ResizePolicy::Type)jarg2;
27847   arg3 = (Dali::Dimension::Type)jarg3;
27848   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27849   if (!darg) {
27850     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27851     return;
27852   }
27853   {
27854     try {
27855       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
27856     } CALL_CATCH_EXCEPTION();
27857   }
27858
27859 }
27860
27861
27862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
27863   void * jresult ;
27864   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27865   SwigDirector_ViewImpl *darg = 0;
27866   Dali::Vector3 result;
27867
27868   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27869   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27870   if (!darg) {
27871     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27872     return 0;
27873   }
27874   {
27875     try {
27876       result = (darg)->GetNaturalSize();
27877     } CALL_CATCH_EXCEPTION(0);
27878   }
27879
27880   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
27881   return jresult;
27882 }
27883
27884
27885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
27886   void * jresult ;
27887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27888   SwigDirector_ViewImpl *darg = 0;
27889   Dali::Vector3 result;
27890
27891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27892   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27893   if (!darg) {
27894     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27895     return 0;
27896   }
27897   {
27898     try {
27899       result = (darg)->GetNaturalSizeSwigPublic();
27900     } CALL_CATCH_EXCEPTION(0);
27901   }
27902
27903   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
27904   return jresult;
27905 }
27906
27907
27908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
27909   float jresult ;
27910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27911   Dali::Actor *arg2 = 0 ;
27912   Dali::Dimension::Type arg3 ;
27913   SwigDirector_ViewImpl *darg = 0;
27914   float result;
27915
27916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27917   arg2 = (Dali::Actor *)jarg2;
27918   if (!arg2) {
27919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27920     return 0;
27921   }
27922   arg3 = (Dali::Dimension::Type)jarg3;
27923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27924   if (!darg) {
27925     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27926     return 0;
27927   }
27928   {
27929     try {
27930       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
27931     } CALL_CATCH_EXCEPTION(0);
27932   }
27933
27934   jresult = result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
27940   float jresult ;
27941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27942   Dali::Actor *arg2 = 0 ;
27943   Dali::Dimension::Type arg3 ;
27944   SwigDirector_ViewImpl *darg = 0;
27945   float result;
27946
27947   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27948   arg2 = (Dali::Actor *)jarg2;
27949   if (!arg2) {
27950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
27951     return 0;
27952   }
27953   arg3 = (Dali::Dimension::Type)jarg3;
27954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27955   if (!darg) {
27956     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27957     return 0;
27958   }
27959   {
27960     try {
27961       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
27962     } CALL_CATCH_EXCEPTION(0);
27963   }
27964
27965   jresult = result;
27966   return jresult;
27967 }
27968
27969
27970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
27971   float jresult ;
27972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27973   float arg2 ;
27974   SwigDirector_ViewImpl *darg = 0;
27975   float result;
27976
27977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
27978   arg2 = (float)jarg2;
27979   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
27980   if (!darg) {
27981     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
27982     return 0;
27983   }
27984   {
27985     try {
27986       result = (float)(darg)->GetHeightForWidth(arg2);
27987     } CALL_CATCH_EXCEPTION(0);
27988   }
27989
27990   jresult = result;
27991   return jresult;
27992 }
27993
27994
27995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
27996   float jresult ;
27997   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
27998   float arg2 ;
27999   SwigDirector_ViewImpl *darg = 0;
28000   float result;
28001
28002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28003   arg2 = (float)jarg2;
28004   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28005   if (!darg) {
28006     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28007     return 0;
28008   }
28009   {
28010     try {
28011       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
28012     } CALL_CATCH_EXCEPTION(0);
28013   }
28014
28015   jresult = result;
28016   return jresult;
28017 }
28018
28019
28020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
28021   float jresult ;
28022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28023   float arg2 ;
28024   SwigDirector_ViewImpl *darg = 0;
28025   float result;
28026
28027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28028   arg2 = (float)jarg2;
28029   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28030   if (!darg) {
28031     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28032     return 0;
28033   }
28034   {
28035     try {
28036       result = (float)(darg)->GetWidthForHeight(arg2);
28037     } CALL_CATCH_EXCEPTION(0);
28038   }
28039
28040   jresult = result;
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
28046   float jresult ;
28047   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28048   float arg2 ;
28049   SwigDirector_ViewImpl *darg = 0;
28050   float result;
28051
28052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28053   arg2 = (float)jarg2;
28054   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28055   if (!darg) {
28056     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28057     return 0;
28058   }
28059   {
28060     try {
28061       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
28062     } CALL_CATCH_EXCEPTION(0);
28063   }
28064
28065   jresult = result;
28066   return jresult;
28067 }
28068
28069
28070 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
28071   bool jresult ;
28072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28073   Dali::Dimension::Type arg2 ;
28074   SwigDirector_ViewImpl *darg = 0;
28075   bool result;
28076
28077   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28078   arg2 = (Dali::Dimension::Type)jarg2;
28079   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28080   if (!darg) {
28081     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28082     return 0;
28083   }
28084   {
28085     try {
28086       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
28087     } CALL_CATCH_EXCEPTION(0);
28088   }
28089
28090   jresult = result;
28091   return jresult;
28092 }
28093
28094
28095 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
28096   bool jresult ;
28097   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28098   Dali::Dimension::Type arg2 ;
28099   SwigDirector_ViewImpl *darg = 0;
28100   bool result;
28101
28102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28103   arg2 = (Dali::Dimension::Type)jarg2;
28104   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28105   if (!darg) {
28106     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28107     return 0;
28108   }
28109   {
28110     try {
28111       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
28112     } CALL_CATCH_EXCEPTION(0);
28113   }
28114
28115   jresult = result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
28121   bool jresult ;
28122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28123   SwigDirector_ViewImpl *darg = 0;
28124   bool result;
28125
28126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28127   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28128   if (!darg) {
28129     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28130     return 0;
28131   }
28132   {
28133     try {
28134       result = (bool)(darg)->RelayoutDependentOnChildren();
28135     } CALL_CATCH_EXCEPTION(0);
28136   }
28137
28138   jresult = result;
28139   return jresult;
28140 }
28141
28142
28143 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
28144   bool jresult ;
28145   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28146   SwigDirector_ViewImpl *darg = 0;
28147   bool result;
28148
28149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28150   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28151   if (!darg) {
28152     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28153     return 0;
28154   }
28155   {
28156     try {
28157       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
28158     } CALL_CATCH_EXCEPTION(0);
28159   }
28160
28161   jresult = result;
28162   return jresult;
28163 }
28164
28165
28166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
28167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28168   Dali::Dimension::Type arg2 ;
28169   SwigDirector_ViewImpl *darg = 0;
28170
28171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28172   arg2 = (Dali::Dimension::Type)jarg2;
28173   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28174   if (!darg) {
28175     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28176     return;
28177   }
28178   {
28179     try {
28180       (darg)->OnCalculateRelayoutSize(arg2);
28181     } CALL_CATCH_EXCEPTION();
28182   }
28183
28184 }
28185
28186
28187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
28188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28189   Dali::Dimension::Type arg2 ;
28190   SwigDirector_ViewImpl *darg = 0;
28191
28192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28193   arg2 = (Dali::Dimension::Type)jarg2;
28194   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28195   if (!darg) {
28196     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28197     return;
28198   }
28199   {
28200     try {
28201       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
28202     } CALL_CATCH_EXCEPTION();
28203   }
28204
28205 }
28206
28207
28208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
28209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28210   float arg2 ;
28211   Dali::Dimension::Type arg3 ;
28212   SwigDirector_ViewImpl *darg = 0;
28213
28214   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28215   arg2 = (float)jarg2;
28216   arg3 = (Dali::Dimension::Type)jarg3;
28217   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28218   if (!darg) {
28219     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28220     return;
28221   }
28222   {
28223     try {
28224       (darg)->OnLayoutNegotiated(arg2,arg3);
28225     } CALL_CATCH_EXCEPTION();
28226   }
28227
28228 }
28229
28230
28231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
28232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
28233   float arg2 ;
28234   Dali::Dimension::Type arg3 ;
28235   SwigDirector_ViewImpl *darg = 0;
28236
28237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
28238   arg2 = (float)jarg2;
28239   arg3 = (Dali::Dimension::Type)jarg3;
28240   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
28241   if (!darg) {
28242     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
28243     return;
28244   }
28245   {
28246     try {
28247       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
28248     } CALL_CATCH_EXCEPTION();
28249   }
28250
28251 }
28252
28253
28254 // TODO : SwigDirector_ItemFactory
28255
28256
28257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
28258   void * jresult ;
28259   Dali::Toolkit::ItemFactory *result = 0 ;
28260
28261   {
28262     try {
28263       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
28264     } CALL_CATCH_EXCEPTION(0);
28265   }
28266
28267   jresult = (void *)result;
28268   return jresult;
28269 }
28270
28271 #ifdef __cplusplus
28272 }
28273 #endif