plugins/dali-swig/automatic/cpp/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
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/public-api/math/matrix.h>
 427 #include <dali/public-api/math/matrix3.h>
 428 #include <dali/public-api/math/viewport.h>
 429 #include <dali/public-api/object/property-key.h>
 430
 431 #include <dali/public-api/adaptor-framework/timer.h>
 432 #include <dali/public-api/adaptor-framework/window.h>
 433 #include <dali/public-api/adaptor-framework/style-change.h>
 434 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 435
 436 #include <dali/devel-api/images/nine-patch-image.h>
 437
 438 #include <dali-toolkit/devel-api/builder/builder.h>
 439 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 440 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 441 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 442 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 443 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 444 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 445 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 446
 447 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 448 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 449
 450 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 451
 452 // add here SWIG version check
 453
 454 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 455 // disable Swig-dependent warnings
 456
 457 // 'identifier1' has C-linkage specified,
 458 // but returns UDT 'identifier2' which is incompatible with C
 459 #pragma warning(disable: 4190)
 460
 461 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 462 #pragma warning(disable: 4800)
 463
 464 // debug info too long etc etc
 465 #pragma warning(disable: 4786)
 466 #endif
 467
 468
 469 #include <stdexcept>
 470
 471
 472 #include <string>
 473
 474
 475 #include <vector>
 476 #include <algorithm>
 477 #include <stdexcept>
 478
 479
 480 #include <map>
 481 #include <algorithm>
 482 #include <stdexcept>
 483
 484
 485 #include <utility>
 486
 487
 488 typedef float floatp;
 489
 490 SWIGINTERN floatp *new_floatp(){
 491   return new float();
 492 }
 493 SWIGINTERN void delete_floatp(floatp *self){
 494   if (self) delete self;
 495 }
 496 SWIGINTERN void floatp_assign(floatp *self,float value){
 497   *self = value;
 498 }
 499 SWIGINTERN float floatp_value(floatp *self){
 500   return *self;
 501 }
 502 SWIGINTERN float *floatp_cast(floatp *self){
 503   return self;
 504 }
 505 SWIGINTERN floatp *floatp_frompointer(float *t){
 506   return (floatp *) t;
 507 }
 508
 509 typedef int intp;
 510
 511 SWIGINTERN intp *new_intp(){
 512   return new int();
 513 }
 514 SWIGINTERN void delete_intp(intp *self){
 515   if (self) delete self;
 516 }
 517 SWIGINTERN void intp_assign(intp *self,int value){
 518   *self = value;
 519 }
 520 SWIGINTERN int intp_value(intp *self){
 521   return *self;
 522 }
 523 SWIGINTERN int *intp_cast(intp *self){
 524   return self;
 525 }
 526 SWIGINTERN intp *intp_frompointer(int *t){
 527   return (intp *) t;
 528 }
 529
 530 typedef double doublep;
 531
 532 SWIGINTERN doublep *new_doublep(){
 533   return new double();
 534 }
 535 SWIGINTERN void delete_doublep(doublep *self){
 536   if (self) delete self;
 537 }
 538 SWIGINTERN void doublep_assign(doublep *self,double value){
 539   *self = value;
 540 }
 541 SWIGINTERN double doublep_value(doublep *self){
 542   return *self;
 543 }
 544 SWIGINTERN double *doublep_cast(doublep *self){
 545   return self;
 546 }
 547 SWIGINTERN doublep *doublep_frompointer(double *t){
 548   return (doublep *) t;
 549 }
 550
 551 typedef unsigned int uintp;
 552
 553 SWIGINTERN uintp *new_uintp(){
 554   return new unsigned int();
 555 }
 556 SWIGINTERN void delete_uintp(uintp *self){
 557   if (self) delete self;
 558 }
 559 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 560   *self = value;
 561 }
 562 SWIGINTERN unsigned int uintp_value(uintp *self){
 563   return *self;
 564 }
 565 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 566   return self;
 567 }
 568 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 569   return (uintp *) t;
 570 }
 571
 572 typedef unsigned short ushortp;
 573
 574 SWIGINTERN ushortp *new_ushortp(){
 575   return new unsigned short();
 576 }
 577 SWIGINTERN void delete_ushortp(ushortp *self){
 578   if (self) delete self;
 579 }
 580 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 581   *self = value;
 582 }
 583 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 584   return *self;
 585 }
 586 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 587   return self;
 588 }
 589 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 590   return (ushortp *) t;
 591 }
 592
 593 unsigned int int_to_uint(int x) {
 594    return (unsigned int) x;
 595 }
 596
 597
 598 using namespace Dali;
 599 using namespace Dali::Toolkit;
 600
 601 SWIGINTERN bool Dali_BaseHandle_IsHandleEmpty(Dali::BaseHandle const *self){
 602      if( *self )
 603      {
 604        return true;
 605      }
 606      else
 607      {
 608        return false;
 609      }
 610     }
 611 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 612         std::vector< Dali::TouchPoint >* pv = 0;
 613         if (capacity >= 0) {
 614           pv = new std::vector< Dali::TouchPoint >();
 615           pv->reserve(capacity);
 616        } else {
 617           throw std::out_of_range("capacity");
 618        }
 619        return pv;
 620       }
 621 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 622         if (index>=0 && index<(int)self->size())
 623           return (*self)[index];
 624         else
 625           throw std::out_of_range("index");
 626       }
 627 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 628         if (index>=0 && index<(int)self->size())
 629           return (*self)[index];
 630         else
 631           throw std::out_of_range("index");
 632       }
 633 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 634         if (index>=0 && index<(int)self->size())
 635           (*self)[index] = val;
 636         else
 637           throw std::out_of_range("index");
 638       }
 639 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 640         self->insert(self->end(), values.begin(), values.end());
 641       }
 642 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(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         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 650       }
 651 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 652         if (index>=0 && index<(int)self->size()+1)
 653           self->insert(self->begin()+index, x);
 654         else
 655           throw std::out_of_range("index");
 656       }
 657 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 658         if (index>=0 && index<(int)self->size()+1)
 659           self->insert(self->begin()+index, values.begin(), values.end());
 660         else
 661           throw std::out_of_range("index");
 662       }
 663 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 664         if (index>=0 && index<(int)self->size())
 665           self->erase(self->begin() + index);
 666         else
 667           throw std::out_of_range("index");
 668       }
 669 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 670         if (index < 0)
 671           throw std::out_of_range("index");
 672         if (count < 0)
 673           throw std::out_of_range("count");
 674         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 675           throw std::invalid_argument("invalid range");
 676         self->erase(self->begin()+index, self->begin()+index+count);
 677       }
 678 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 679         if (count < 0)
 680           throw std::out_of_range("count");
 681         return new std::vector< Dali::TouchPoint >(count, value);
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 684         std::reverse(self->begin(), self->end());
 685       }
 686 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 687         if (index < 0)
 688           throw std::out_of_range("index");
 689         if (count < 0)
 690           throw std::out_of_range("count");
 691         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 692           throw std::invalid_argument("invalid range");
 693         std::reverse(self->begin()+index, self->begin()+index+count);
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 696         if (index < 0)
 697           throw std::out_of_range("index");
 698         if (index+values.size() > self->size())
 699           throw std::out_of_range("index");
 700         std::copy(values.begin(), values.end(), self->begin()+index);
 701       }
 702 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 703          return self->Empty();
 704       }
 705 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 706         return self->GetConnectionCount();
 707       }
 708 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 709           self->Connect( func );
 710       }
 711 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 712           self->Disconnect( func );
 713       }
 714 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 715           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 716 /*@SWIG@*/ self->Emit( arg );
 717       }
 718 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 719          return self->Empty();
 720       }
 721 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 722         return self->GetConnectionCount();
 723       }
 724 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 725           self->Connect( func );
 726       }
 727 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 728           self->Disconnect( func );
 729       }
 730 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 731           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 732 /*@SWIG@*/ self->Emit( arg );
 733       }
 734 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 735          return self->Empty();
 736       }
 737 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 738         return self->GetConnectionCount();
 739       }
 740 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 741           self->Connect( func );
 742       }
 743 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 744           self->Disconnect( func );
 745       }
 746 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 747           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 748 /*@SWIG@*/ self->Emit( arg );
 749       }
 750 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 751          return self->Empty();
 752       }
 753 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 754         return self->GetConnectionCount();
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 757           self->Connect( func );
 758       }
 759 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 760           self->Disconnect( func );
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 763           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 764 /*@SWIG@*/ self->Emit( arg );
 765       }
 766 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 767          return self->Empty();
 768       }
 769 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 770         return self->GetConnectionCount();
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 773           self->Connect( func );
 774       }
 775 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 776           self->Disconnect( func );
 777       }
 778 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 779           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 780 /*@SWIG@*/ self->Emit( arg );
 781       }
 782 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 783          return self->Empty();
 784       }
 785 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 786         return self->GetConnectionCount();
 787       }
 788 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 789         self->Connect( func );
 790       }
 791 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 792         self->Disconnect( func );
 793       }
 794 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 795         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 796 /*@SWIG@*/ self->Emit( arg1, arg2 );
 797       }
 798 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 799          return self->Empty();
 800       }
 801 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 802         return self->GetConnectionCount();
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 805         self->Connect( func );
 806       }
 807 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 808         self->Disconnect( func );
 809       }
 810 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 811         return self->Emit( arg1, arg2 );
 812       }
 813 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 814          return self->Empty();
 815       }
 816 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 817         return self->GetConnectionCount();
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 820         self->Connect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 823         self->Disconnect( func );
 824       }
 825 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 826         return self->Emit( arg1, arg2 );
 827       }
 828 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 829          return self->Empty();
 830       }
 831 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 832         return self->GetConnectionCount();
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 835         self->Connect( func );
 836       }
 837 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 838         self->Disconnect( func );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 841         return self->Emit( arg1, arg2 );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 850           self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 853           self->Disconnect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 860          return self->Empty();
 861       }
 862 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){
 863         return self->GetConnectionCount();
 864       }
 865 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 &)){
 866           self->Connect( func );
 867       }
 868 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 &)){
 869           self->Disconnect( func );
 870       }
 871 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){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 876          return self->Empty();
 877       }
 878 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 879         return self->GetConnectionCount();
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 882           self->Connect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 885           self->Disconnect( func );
 886       }
 887 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 888           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg );
 890       }
 891 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 892          return self->Empty();
 893       }
 894 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){
 895         return self->GetConnectionCount();
 896       }
 897 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 &)){
 898           self->Connect( func );
 899       }
 900 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 &)){
 901           self->Disconnect( func );
 902       }
 903 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){
 904           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 905 /*@SWIG@*/ self->Emit( arg );
 906       }
 907 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){
 908          return self->Empty();
 909       }
 910 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){
 911         return self->GetConnectionCount();
 912       }
 913 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 &)){
 914         self->Connect( func );
 915       }
 916 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 &)){
 917         self->Disconnect( func );
 918       }
 919 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){
 920         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 921 /*@SWIG@*/ self->Emit( arg1, arg2 );
 922       }
 923 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){
 924          return self->Empty();
 925       }
 926 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){
 927         return self->GetConnectionCount();
 928       }
 929 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 &)){
 930         self->Connect( func );
 931       }
 932 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 &)){
 933         self->Disconnect( func );
 934       }
 935 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){
 936         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 937 /*@SWIG@*/ self->Emit( arg1, arg2 );
 938       }
 939 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){
 940          return self->Empty();
 941       }
 942 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){
 943         return self->GetConnectionCount();
 944       }
 945 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 &)){
 946         self->Connect( func );
 947       }
 948 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 &)){
 949         self->Disconnect( func );
 950       }
 951 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){
 952         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 953 /*@SWIG@*/ self->Emit( arg1, arg2 );
 954       }
 955 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 956          return self->Empty();
 957       }
 958 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 959         return self->GetConnectionCount();
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 962           self->Connect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 965           self->Disconnect( func );
 966       }
 967 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
 968           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 969 /*@SWIG@*/ self->Emit( arg );
 970       }
 971 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
 972          return self->Empty();
 973       }
 974 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
 975         return self->GetConnectionCount();
 976       }
 977 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
 978           self->Connect( func );
 979       }
 980 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
 981           self->Disconnect( func );
 982       }
 983 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
 984           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 985 /*@SWIG@*/ self->Emit( arg );
 986       }
 987
 988   // keep argcs and argv so they're always available to DALi
 989   int argC = 1;
 990   char **argV = NULL;
 991
 992 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
 993          return self->Empty();
 994       }
 995 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
 996         return self->GetConnectionCount();
 997       }
 998 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
 999           self->Connect( func );
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1002           self->Disconnect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1005           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1006 /*@SWIG@*/ self->Emit( arg );
1007       }
1008 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1009          return self->Empty();
1010       }
1011 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1012         return self->GetConnectionCount();
1013       }
1014 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1015         self->Connect( func );
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1018         self->Disconnect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1021         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1022 /*@SWIG@*/ self->Emit( arg1, arg2 );
1023       }
1024 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1025         std::vector< unsigned int >* pv = 0;
1026         if (capacity >= 0) {
1027           pv = new std::vector< unsigned int >();
1028           pv->reserve(capacity);
1029        } else {
1030           throw std::out_of_range("capacity");
1031        }
1032        return pv;
1033       }
1034 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1035         if (index>=0 && index<(int)self->size())
1036           return (*self)[index];
1037         else
1038           throw std::out_of_range("index");
1039       }
1040 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1041         if (index>=0 && index<(int)self->size())
1042           return (*self)[index];
1043         else
1044           throw std::out_of_range("index");
1045       }
1046 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1047         if (index>=0 && index<(int)self->size())
1048           (*self)[index] = val;
1049         else
1050           throw std::out_of_range("index");
1051       }
1052 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1053         self->insert(self->end(), values.begin(), values.end());
1054       }
1055 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1056         if (index < 0)
1057           throw std::out_of_range("index");
1058         if (count < 0)
1059           throw std::out_of_range("count");
1060         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1061           throw std::invalid_argument("invalid range");
1062         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1063       }
1064 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1065         if (index>=0 && index<(int)self->size()+1)
1066           self->insert(self->begin()+index, x);
1067         else
1068           throw std::out_of_range("index");
1069       }
1070 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1071         if (index>=0 && index<(int)self->size()+1)
1072           self->insert(self->begin()+index, values.begin(), values.end());
1073         else
1074           throw std::out_of_range("index");
1075       }
1076 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1077         if (index>=0 && index<(int)self->size())
1078           self->erase(self->begin() + index);
1079         else
1080           throw std::out_of_range("index");
1081       }
1082 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1083         if (index < 0)
1084           throw std::out_of_range("index");
1085         if (count < 0)
1086           throw std::out_of_range("count");
1087         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1088           throw std::invalid_argument("invalid range");
1089         self->erase(self->begin()+index, self->begin()+index+count);
1090       }
1091 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1092         if (count < 0)
1093           throw std::out_of_range("count");
1094         return new std::vector< unsigned int >(count, value);
1095       }
1096 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1097         std::reverse(self->begin(), self->end());
1098       }
1099 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1100         if (index < 0)
1101           throw std::out_of_range("index");
1102         if (count < 0)
1103           throw std::out_of_range("count");
1104         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1105           throw std::invalid_argument("invalid range");
1106         std::reverse(self->begin()+index, self->begin()+index+count);
1107       }
1108 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1109         if (index < 0)
1110           throw std::out_of_range("index");
1111         if (index+values.size() > self->size())
1112           throw std::out_of_range("index");
1113         std::copy(values.begin(), values.end(), self->begin()+index);
1114       }
1115 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1116         return std::find(self->begin(), self->end(), value) != self->end();
1117       }
1118 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1119         int index = -1;
1120         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1121         if (it != self->end())
1122           index = (int)(it - self->begin());
1123         return index;
1124       }
1125 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1126         int index = -1;
1127         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1128         if (rit != self->rend())
1129           index = (int)(self->rend() - 1 - rit);
1130         return index;
1131       }
1132 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1133         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1134         if (it != self->end()) {
1135           self->erase(it);
1136           return true;
1137         }
1138         return false;
1139       }
1140 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){
1141         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1142         if (capacity >= 0) {
1143           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1144           pv->reserve(capacity);
1145        } else {
1146           throw std::out_of_range("capacity");
1147        }
1148        return pv;
1149       }
1150 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){
1151         if (index>=0 && index<(int)self->size())
1152           return (*self)[index];
1153         else
1154           throw std::out_of_range("index");
1155       }
1156 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){
1157         if (index>=0 && index<(int)self->size())
1158           return (*self)[index];
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 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){
1163         if (index>=0 && index<(int)self->size())
1164           (*self)[index] = val;
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 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){
1169         self->insert(self->end(), values.begin(), values.end());
1170       }
1171 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){
1172         if (index < 0)
1173           throw std::out_of_range("index");
1174         if (count < 0)
1175           throw std::out_of_range("count");
1176         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1177           throw std::invalid_argument("invalid range");
1178         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1179       }
1180 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){
1181         if (index>=0 && index<(int)self->size()+1)
1182           self->insert(self->begin()+index, x);
1183         else
1184           throw std::out_of_range("index");
1185       }
1186 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){
1187         if (index>=0 && index<(int)self->size()+1)
1188           self->insert(self->begin()+index, values.begin(), values.end());
1189         else
1190           throw std::out_of_range("index");
1191       }
1192 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){
1193         if (index>=0 && index<(int)self->size())
1194           self->erase(self->begin() + index);
1195         else
1196           throw std::out_of_range("index");
1197       }
1198 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){
1199         if (index < 0)
1200           throw std::out_of_range("index");
1201         if (count < 0)
1202           throw std::out_of_range("count");
1203         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1204           throw std::invalid_argument("invalid range");
1205         self->erase(self->begin()+index, self->begin()+index+count);
1206       }
1207 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){
1208         if (count < 0)
1209           throw std::out_of_range("count");
1210         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1211       }
1212 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){
1213         std::reverse(self->begin(), self->end());
1214       }
1215 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){
1216         if (index < 0)
1217           throw std::out_of_range("index");
1218         if (count < 0)
1219           throw std::out_of_range("count");
1220         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1221           throw std::invalid_argument("invalid range");
1222         std::reverse(self->begin()+index, self->begin()+index+count);
1223       }
1224 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){
1225         if (index < 0)
1226           throw std::out_of_range("index");
1227         if (index+values.size() > self->size())
1228           throw std::out_of_range("index");
1229         std::copy(values.begin(), values.end(), self->begin()+index);
1230       }
1231 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1232         std::vector< Dali::Actor >* pv = 0;
1233         if (capacity >= 0) {
1234           pv = new std::vector< Dali::Actor >();
1235           pv->reserve(capacity);
1236        } else {
1237           throw std::out_of_range("capacity");
1238        }
1239        return pv;
1240       }
1241 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1242         if (index>=0 && index<(int)self->size())
1243           return (*self)[index];
1244         else
1245           throw std::out_of_range("index");
1246       }
1247 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1248         if (index>=0 && index<(int)self->size())
1249           return (*self)[index];
1250         else
1251           throw std::out_of_range("index");
1252       }
1253 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1254         if (index>=0 && index<(int)self->size())
1255           (*self)[index] = val;
1256         else
1257           throw std::out_of_range("index");
1258       }
1259 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1260         self->insert(self->end(), values.begin(), values.end());
1261       }
1262 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1263         if (index < 0)
1264           throw std::out_of_range("index");
1265         if (count < 0)
1266           throw std::out_of_range("count");
1267         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1268           throw std::invalid_argument("invalid range");
1269         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1270       }
1271 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1272         if (index>=0 && index<(int)self->size()+1)
1273           self->insert(self->begin()+index, x);
1274         else
1275           throw std::out_of_range("index");
1276       }
1277 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1278         if (index>=0 && index<(int)self->size()+1)
1279           self->insert(self->begin()+index, values.begin(), values.end());
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1284         if (index>=0 && index<(int)self->size())
1285           self->erase(self->begin() + index);
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1290         if (index < 0)
1291           throw std::out_of_range("index");
1292         if (count < 0)
1293           throw std::out_of_range("count");
1294         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1295           throw std::invalid_argument("invalid range");
1296         self->erase(self->begin()+index, self->begin()+index+count);
1297       }
1298 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1299         if (count < 0)
1300           throw std::out_of_range("count");
1301         return new std::vector< Dali::Actor >(count, value);
1302       }
1303 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1304         std::reverse(self->begin(), self->end());
1305       }
1306 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1307         if (index < 0)
1308           throw std::out_of_range("index");
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1312           throw std::invalid_argument("invalid range");
1313         std::reverse(self->begin()+index, self->begin()+index+count);
1314       }
1315 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1316         if (index < 0)
1317           throw std::out_of_range("index");
1318         if (index+values.size() > self->size())
1319           throw std::out_of_range("index");
1320         std::copy(values.begin(), values.end(), self->begin()+index);
1321       }
1322 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1323          return self->Empty();
1324       }
1325 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1326         return self->GetConnectionCount();
1327       }
1328 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1329           self->Connect( func );
1330       }
1331 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1332           self->Disconnect( func );
1333       }
1334 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1335           return self->Emit( arg );
1336       }
1337 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
1338          return self->Empty();
1339       }
1340 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
1341         return self->GetConnectionCount();
1342       }
1343 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
1344         self->Connect( func );
1345       }
1346 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
1347         self->Disconnect( func );
1348       }
1349 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,Dali::Toolkit::AccessibilityManager &arg1,Dali::TouchEvent const &arg2){
1350         return self->Emit( arg1, arg2 );
1351       }
1352 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1353          return self->Empty();
1354       }
1355 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1356         return self->GetConnectionCount();
1357       }
1358 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1359         self->Connect( func );
1360       }
1361 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1362         self->Disconnect( func );
1363       }
1364 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1365         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1366 /*@SWIG@*/ self->Emit( arg1, arg2 );
1367       }
1368 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1369          return self->Empty();
1370       }
1371 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){
1372         return self->GetConnectionCount();
1373       }
1374 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)){
1375         self->Connect( func );
1376       }
1377 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)){
1378         self->Disconnect( func );
1379       }
1380 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){
1381         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1382 /*@SWIG@*/ self->Emit( arg1, arg2 );
1383       }
1384 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1385          return self->Empty();
1386       }
1387 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1388         return self->GetConnectionCount();
1389       }
1390 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)){
1391         self->Connect( func );
1392       }
1393 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)){
1394         self->Disconnect( func );
1395       }
1396 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){
1397         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1398 /*@SWIG@*/ self->Emit( arg1, arg2 );
1399       }
1400 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1401          return self->Empty();
1402       }
1403 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1404         return self->GetConnectionCount();
1405       }
1406 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1407         self->Connect( func );
1408       }
1409 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1410         self->Disconnect( func );
1411       }
1412 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1413         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1414 /*@SWIG@*/ self->Emit( arg1, arg2 );
1415       }
1416 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1417          return self->Empty();
1418       }
1419 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1420         return self->GetConnectionCount();
1421       }
1422 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1423           self->Connect( func );
1424       }
1425 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1426           self->Disconnect( func );
1427       }
1428 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1429           return self->Emit( arg );
1430       }
1431 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1432          return self->Empty();
1433       }
1434 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1435         return self->GetConnectionCount();
1436       }
1437 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1438           self->Connect( func );
1439       }
1440 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1441           self->Disconnect( func );
1442       }
1443 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1444           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg );
1446       }
1447 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1448          return self->Empty();
1449       }
1450 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1451         return self->GetConnectionCount();
1452       }
1453 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1454           return self->Connect( func );
1455       }
1456 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1457           self->Disconnect( func );
1458       }
1459 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1460           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1464          return self->Empty();
1465       }
1466 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1467         return self->GetConnectionCount();
1468       }
1469 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1470           self->Connect( func );
1471       }
1472 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1473           self->Disconnect( func );
1474       }
1475 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1476           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg );
1478       }
1479 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1480          return self->Empty();
1481       }
1482 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1483         return self->GetConnectionCount();
1484       }
1485 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1486           self->Connect( func );
1487       }
1488 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1489           self->Disconnect( func );
1490       }
1491 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1492           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1493 /*@SWIG@*/ self->Emit( arg );
1494       }
1495 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1496          return self->Empty();
1497       }
1498 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1499         return self->GetConnectionCount();
1500       }
1501 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1502           self->Connect( func );
1503       }
1504 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1505           self->Disconnect( func );
1506       }
1507 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1508           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1509 /*@SWIG@*/ self->Emit( arg );
1510       }
1511 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1512          return self->Empty();
1513       }
1514 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1515         return self->GetConnectionCount();
1516       }
1517 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1518           self->Connect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1521           self->Disconnect( func );
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1524           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1525 /*@SWIG@*/ self->Emit( arg );
1526       }
1527 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1528          return self->Empty();
1529       }
1530 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1531         return self->GetConnectionCount();
1532       }
1533 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1534           self->Connect( func );
1535       }
1536 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1537           self->Disconnect( func );
1538       }
1539 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1540           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1541 /*@SWIG@*/ self->Emit( arg );
1542       }
1543 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1544          return self->Empty();
1545       }
1546 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1547         return self->GetConnectionCount();
1548       }
1549 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1550         self->Connect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1553         self->Disconnect( func );
1554       }
1555 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1556         return self->Emit( arg1, arg2 );
1557       }
1558 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1559          return self->Empty();
1560       }
1561 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1562         return self->GetConnectionCount();
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1565           self->Connect( func );
1566       }
1567 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1568           self->Disconnect( func );
1569       }
1570 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg );
1573       }
1574 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1575          return self->Empty();
1576       }
1577 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1578         return self->GetConnectionCount();
1579       }
1580 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1581           self->Connect( func );
1582       }
1583 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1584           self->Disconnect( func );
1585       }
1586 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1591          return self->Empty();
1592       }
1593 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1594         return self->GetConnectionCount();
1595       }
1596 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1597         self->Connect( func );
1598       }
1599 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1600         self->Disconnect( func );
1601       }
1602 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1603         return self->Emit( arg1, arg2 );
1604       }
1605 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1606          return self->Empty();
1607       }
1608 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1609         return self->GetConnectionCount();
1610       }
1611 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1612         self->Connect( func );
1613       }
1614 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1615         self->Disconnect( func );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1618         return self->Emit( arg1, arg2 );
1619       }
1620
1621
1622 /* ---------------------------------------------------
1623  * C++ director class methods
1624  * --------------------------------------------------- */
1625
1626 #include "dali_wrap.h"
1627
1628
1629 #ifdef __cplusplus
1630 extern "C" {
1631 #endif
1632
1633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
1634   void * jresult ;
1635   floatp *result = 0 ;
1636
1637   {
1638     try {
1639       result = (floatp *)new_floatp();
1640     } catch (std::out_of_range& e) {
1641       {
1642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1643       };
1644     } catch (std::exception& e) {
1645       {
1646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1647       };
1648     } catch (...) {
1649       {
1650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1651       };
1652     }
1653   }
1654   jresult = (void *)result;
1655   return jresult;
1656 }
1657
1658
1659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
1660   floatp *arg1 = (floatp *) 0 ;
1661
1662   arg1 = (floatp *)jarg1;
1663   {
1664     try {
1665       delete_floatp(arg1);
1666     } catch (std::out_of_range& e) {
1667       {
1668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1669       };
1670     } catch (std::exception& e) {
1671       {
1672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1673       };
1674     } catch (...) {
1675       {
1676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1677       };
1678     }
1679   }
1680 }
1681
1682
1683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
1684   floatp *arg1 = (floatp *) 0 ;
1685   float arg2 ;
1686
1687   arg1 = (floatp *)jarg1;
1688   arg2 = (float)jarg2;
1689   {
1690     try {
1691       floatp_assign(arg1,arg2);
1692     } catch (std::out_of_range& e) {
1693       {
1694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1695       };
1696     } catch (std::exception& e) {
1697       {
1698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1699       };
1700     } catch (...) {
1701       {
1702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1703       };
1704     }
1705   }
1706 }
1707
1708
1709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
1710   float jresult ;
1711   floatp *arg1 = (floatp *) 0 ;
1712   float result;
1713
1714   arg1 = (floatp *)jarg1;
1715   {
1716     try {
1717       result = (float)floatp_value(arg1);
1718     } catch (std::out_of_range& e) {
1719       {
1720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1721       };
1722     } catch (std::exception& e) {
1723       {
1724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1725       };
1726     } catch (...) {
1727       {
1728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1729       };
1730     }
1731   }
1732   jresult = result;
1733   return jresult;
1734 }
1735
1736
1737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
1738   void * jresult ;
1739   floatp *arg1 = (floatp *) 0 ;
1740   float *result = 0 ;
1741
1742   arg1 = (floatp *)jarg1;
1743   {
1744     try {
1745       result = (float *)floatp_cast(arg1);
1746     } catch (std::out_of_range& e) {
1747       {
1748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1749       };
1750     } catch (std::exception& e) {
1751       {
1752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1753       };
1754     } catch (...) {
1755       {
1756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1757       };
1758     }
1759   }
1760   jresult = (void *)result;
1761   return jresult;
1762 }
1763
1764
1765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
1766   void * jresult ;
1767   float *arg1 = (float *) 0 ;
1768   floatp *result = 0 ;
1769
1770   arg1 = (float *)jarg1;
1771   {
1772     try {
1773       result = (floatp *)floatp_frompointer(arg1);
1774     } catch (std::out_of_range& e) {
1775       {
1776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1777       };
1778     } catch (std::exception& e) {
1779       {
1780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1781       };
1782     } catch (...) {
1783       {
1784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1785       };
1786     }
1787   }
1788   jresult = (void *)result;
1789   return jresult;
1790 }
1791
1792
1793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
1794   void * jresult ;
1795   intp *result = 0 ;
1796
1797   {
1798     try {
1799       result = (intp *)new_intp();
1800     } catch (std::out_of_range& e) {
1801       {
1802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1803       };
1804     } catch (std::exception& e) {
1805       {
1806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1807       };
1808     } catch (...) {
1809       {
1810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1811       };
1812     }
1813   }
1814   jresult = (void *)result;
1815   return jresult;
1816 }
1817
1818
1819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
1820   intp *arg1 = (intp *) 0 ;
1821
1822   arg1 = (intp *)jarg1;
1823   {
1824     try {
1825       delete_intp(arg1);
1826     } catch (std::out_of_range& e) {
1827       {
1828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1829       };
1830     } catch (std::exception& e) {
1831       {
1832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1833       };
1834     } catch (...) {
1835       {
1836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1837       };
1838     }
1839   }
1840 }
1841
1842
1843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
1844   intp *arg1 = (intp *) 0 ;
1845   int arg2 ;
1846
1847   arg1 = (intp *)jarg1;
1848   arg2 = (int)jarg2;
1849   {
1850     try {
1851       intp_assign(arg1,arg2);
1852     } catch (std::out_of_range& e) {
1853       {
1854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1855       };
1856     } catch (std::exception& e) {
1857       {
1858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1859       };
1860     } catch (...) {
1861       {
1862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1863       };
1864     }
1865   }
1866 }
1867
1868
1869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
1870   int jresult ;
1871   intp *arg1 = (intp *) 0 ;
1872   int result;
1873
1874   arg1 = (intp *)jarg1;
1875   {
1876     try {
1877       result = (int)intp_value(arg1);
1878     } catch (std::out_of_range& e) {
1879       {
1880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1881       };
1882     } catch (std::exception& e) {
1883       {
1884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1885       };
1886     } catch (...) {
1887       {
1888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1889       };
1890     }
1891   }
1892   jresult = result;
1893   return jresult;
1894 }
1895
1896
1897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
1898   void * jresult ;
1899   intp *arg1 = (intp *) 0 ;
1900   int *result = 0 ;
1901
1902   arg1 = (intp *)jarg1;
1903   {
1904     try {
1905       result = (int *)intp_cast(arg1);
1906     } catch (std::out_of_range& e) {
1907       {
1908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1909       };
1910     } catch (std::exception& e) {
1911       {
1912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1913       };
1914     } catch (...) {
1915       {
1916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1917       };
1918     }
1919   }
1920   jresult = (void *)result;
1921   return jresult;
1922 }
1923
1924
1925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
1926   void * jresult ;
1927   int *arg1 = (int *) 0 ;
1928   intp *result = 0 ;
1929
1930   arg1 = (int *)jarg1;
1931   {
1932     try {
1933       result = (intp *)intp_frompointer(arg1);
1934     } catch (std::out_of_range& e) {
1935       {
1936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1937       };
1938     } catch (std::exception& e) {
1939       {
1940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1941       };
1942     } catch (...) {
1943       {
1944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1945       };
1946     }
1947   }
1948   jresult = (void *)result;
1949   return jresult;
1950 }
1951
1952
1953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
1954   void * jresult ;
1955   doublep *result = 0 ;
1956
1957   {
1958     try {
1959       result = (doublep *)new_doublep();
1960     } catch (std::out_of_range& e) {
1961       {
1962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
1963       };
1964     } catch (std::exception& e) {
1965       {
1966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
1967       };
1968     } catch (...) {
1969       {
1970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
1971       };
1972     }
1973   }
1974   jresult = (void *)result;
1975   return jresult;
1976 }
1977
1978
1979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
1980   doublep *arg1 = (doublep *) 0 ;
1981
1982   arg1 = (doublep *)jarg1;
1983   {
1984     try {
1985       delete_doublep(arg1);
1986     } catch (std::out_of_range& e) {
1987       {
1988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
1989       };
1990     } catch (std::exception& e) {
1991       {
1992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
1993       };
1994     } catch (...) {
1995       {
1996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
1997       };
1998     }
1999   }
2000 }
2001
2002
2003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2004   doublep *arg1 = (doublep *) 0 ;
2005   double arg2 ;
2006
2007   arg1 = (doublep *)jarg1;
2008   arg2 = (double)jarg2;
2009   {
2010     try {
2011       doublep_assign(arg1,arg2);
2012     } catch (std::out_of_range& e) {
2013       {
2014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2015       };
2016     } catch (std::exception& e) {
2017       {
2018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2019       };
2020     } catch (...) {
2021       {
2022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2023       };
2024     }
2025   }
2026 }
2027
2028
2029 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2030   double jresult ;
2031   doublep *arg1 = (doublep *) 0 ;
2032   double result;
2033
2034   arg1 = (doublep *)jarg1;
2035   {
2036     try {
2037       result = (double)doublep_value(arg1);
2038     } catch (std::out_of_range& e) {
2039       {
2040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2041       };
2042     } catch (std::exception& e) {
2043       {
2044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2045       };
2046     } catch (...) {
2047       {
2048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2049       };
2050     }
2051   }
2052   jresult = result;
2053   return jresult;
2054 }
2055
2056
2057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2058   void * jresult ;
2059   doublep *arg1 = (doublep *) 0 ;
2060   double *result = 0 ;
2061
2062   arg1 = (doublep *)jarg1;
2063   {
2064     try {
2065       result = (double *)doublep_cast(arg1);
2066     } catch (std::out_of_range& e) {
2067       {
2068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2069       };
2070     } catch (std::exception& e) {
2071       {
2072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2073       };
2074     } catch (...) {
2075       {
2076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2077       };
2078     }
2079   }
2080   jresult = (void *)result;
2081   return jresult;
2082 }
2083
2084
2085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2086   void * jresult ;
2087   double *arg1 = (double *) 0 ;
2088   doublep *result = 0 ;
2089
2090   arg1 = (double *)jarg1;
2091   {
2092     try {
2093       result = (doublep *)doublep_frompointer(arg1);
2094     } catch (std::out_of_range& e) {
2095       {
2096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2097       };
2098     } catch (std::exception& e) {
2099       {
2100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2101       };
2102     } catch (...) {
2103       {
2104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2105       };
2106     }
2107   }
2108   jresult = (void *)result;
2109   return jresult;
2110 }
2111
2112
2113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2114   void * jresult ;
2115   uintp *result = 0 ;
2116
2117   {
2118     try {
2119       result = (uintp *)new_uintp();
2120     } catch (std::out_of_range& e) {
2121       {
2122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2123       };
2124     } catch (std::exception& e) {
2125       {
2126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2127       };
2128     } catch (...) {
2129       {
2130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2131       };
2132     }
2133   }
2134   jresult = (void *)result;
2135   return jresult;
2136 }
2137
2138
2139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2140   uintp *arg1 = (uintp *) 0 ;
2141
2142   arg1 = (uintp *)jarg1;
2143   {
2144     try {
2145       delete_uintp(arg1);
2146     } catch (std::out_of_range& e) {
2147       {
2148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2149       };
2150     } catch (std::exception& e) {
2151       {
2152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2153       };
2154     } catch (...) {
2155       {
2156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2157       };
2158     }
2159   }
2160 }
2161
2162
2163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2164   uintp *arg1 = (uintp *) 0 ;
2165   unsigned int arg2 ;
2166
2167   arg1 = (uintp *)jarg1;
2168   arg2 = (unsigned int)jarg2;
2169   {
2170     try {
2171       uintp_assign(arg1,arg2);
2172     } catch (std::out_of_range& e) {
2173       {
2174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2175       };
2176     } catch (std::exception& e) {
2177       {
2178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2179       };
2180     } catch (...) {
2181       {
2182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2183       };
2184     }
2185   }
2186 }
2187
2188
2189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2190   unsigned int jresult ;
2191   uintp *arg1 = (uintp *) 0 ;
2192   unsigned int result;
2193
2194   arg1 = (uintp *)jarg1;
2195   {
2196     try {
2197       result = (unsigned int)uintp_value(arg1);
2198     } catch (std::out_of_range& e) {
2199       {
2200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2201       };
2202     } catch (std::exception& e) {
2203       {
2204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2205       };
2206     } catch (...) {
2207       {
2208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2209       };
2210     }
2211   }
2212   jresult = result;
2213   return jresult;
2214 }
2215
2216
2217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2218   void * jresult ;
2219   uintp *arg1 = (uintp *) 0 ;
2220   unsigned int *result = 0 ;
2221
2222   arg1 = (uintp *)jarg1;
2223   {
2224     try {
2225       result = (unsigned int *)uintp_cast(arg1);
2226     } catch (std::out_of_range& e) {
2227       {
2228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2229       };
2230     } catch (std::exception& e) {
2231       {
2232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2233       };
2234     } catch (...) {
2235       {
2236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2237       };
2238     }
2239   }
2240   jresult = (void *)result;
2241   return jresult;
2242 }
2243
2244
2245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2246   void * jresult ;
2247   unsigned int *arg1 = (unsigned int *) 0 ;
2248   uintp *result = 0 ;
2249
2250   arg1 = (unsigned int *)jarg1;
2251   {
2252     try {
2253       result = (uintp *)uintp_frompointer(arg1);
2254     } catch (std::out_of_range& e) {
2255       {
2256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2257       };
2258     } catch (std::exception& e) {
2259       {
2260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2261       };
2262     } catch (...) {
2263       {
2264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2265       };
2266     }
2267   }
2268   jresult = (void *)result;
2269   return jresult;
2270 }
2271
2272
2273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
2274   void * jresult ;
2275   ushortp *result = 0 ;
2276
2277   {
2278     try {
2279       result = (ushortp *)new_ushortp();
2280     } catch (std::out_of_range& e) {
2281       {
2282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2283       };
2284     } catch (std::exception& e) {
2285       {
2286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2287       };
2288     } catch (...) {
2289       {
2290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2291       };
2292     }
2293   }
2294   jresult = (void *)result;
2295   return jresult;
2296 }
2297
2298
2299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
2300   ushortp *arg1 = (ushortp *) 0 ;
2301
2302   arg1 = (ushortp *)jarg1;
2303   {
2304     try {
2305       delete_ushortp(arg1);
2306     } catch (std::out_of_range& e) {
2307       {
2308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2309       };
2310     } catch (std::exception& e) {
2311       {
2312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2313       };
2314     } catch (...) {
2315       {
2316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2317       };
2318     }
2319   }
2320 }
2321
2322
2323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
2324   ushortp *arg1 = (ushortp *) 0 ;
2325   unsigned short arg2 ;
2326
2327   arg1 = (ushortp *)jarg1;
2328   arg2 = (unsigned short)jarg2;
2329   {
2330     try {
2331       ushortp_assign(arg1,arg2);
2332     } catch (std::out_of_range& e) {
2333       {
2334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2335       };
2336     } catch (std::exception& e) {
2337       {
2338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2339       };
2340     } catch (...) {
2341       {
2342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2343       };
2344     }
2345   }
2346 }
2347
2348
2349 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
2350   unsigned short jresult ;
2351   ushortp *arg1 = (ushortp *) 0 ;
2352   unsigned short result;
2353
2354   arg1 = (ushortp *)jarg1;
2355   {
2356     try {
2357       result = (unsigned short)ushortp_value(arg1);
2358     } catch (std::out_of_range& e) {
2359       {
2360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2361       };
2362     } catch (std::exception& e) {
2363       {
2364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2365       };
2366     } catch (...) {
2367       {
2368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2369       };
2370     }
2371   }
2372   jresult = result;
2373   return jresult;
2374 }
2375
2376
2377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
2378   void * jresult ;
2379   ushortp *arg1 = (ushortp *) 0 ;
2380   unsigned short *result = 0 ;
2381
2382   arg1 = (ushortp *)jarg1;
2383   {
2384     try {
2385       result = (unsigned short *)ushortp_cast(arg1);
2386     } catch (std::out_of_range& e) {
2387       {
2388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2389       };
2390     } catch (std::exception& e) {
2391       {
2392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2393       };
2394     } catch (...) {
2395       {
2396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2397       };
2398     }
2399   }
2400   jresult = (void *)result;
2401   return jresult;
2402 }
2403
2404
2405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
2406   void * jresult ;
2407   unsigned short *arg1 = (unsigned short *) 0 ;
2408   ushortp *result = 0 ;
2409
2410   arg1 = (unsigned short *)jarg1;
2411   {
2412     try {
2413       result = (ushortp *)ushortp_frompointer(arg1);
2414     } catch (std::out_of_range& e) {
2415       {
2416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2417       };
2418     } catch (std::exception& e) {
2419       {
2420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2421       };
2422     } catch (...) {
2423       {
2424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2425       };
2426     }
2427   }
2428   jresult = (void *)result;
2429   return jresult;
2430 }
2431
2432
2433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
2434   unsigned int jresult ;
2435   int arg1 ;
2436   unsigned int result;
2437
2438   arg1 = (int)jarg1;
2439   {
2440     try {
2441       result = (unsigned int)int_to_uint(arg1);
2442     } catch (std::out_of_range& e) {
2443       {
2444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2445       };
2446     } catch (std::exception& e) {
2447       {
2448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2449       };
2450     } catch (...) {
2451       {
2452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2453       };
2454     }
2455   }
2456   jresult = result;
2457   return jresult;
2458 }
2459
2460
2461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
2462   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2463
2464   arg1 = (Dali::RefObject *)jarg1;
2465   {
2466     try {
2467       (arg1)->Reference();
2468     } catch (std::out_of_range& e) {
2469       {
2470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2471       };
2472     } catch (std::exception& e) {
2473       {
2474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2475       };
2476     } catch (...) {
2477       {
2478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2479       };
2480     }
2481   }
2482 }
2483
2484
2485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
2486   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2487
2488   arg1 = (Dali::RefObject *)jarg1;
2489   {
2490     try {
2491       (arg1)->Unreference();
2492     } catch (std::out_of_range& e) {
2493       {
2494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2495       };
2496     } catch (std::exception& e) {
2497       {
2498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2499       };
2500     } catch (...) {
2501       {
2502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2503       };
2504     }
2505   }
2506 }
2507
2508
2509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
2510   int jresult ;
2511   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
2512   int result;
2513
2514   arg1 = (Dali::RefObject *)jarg1;
2515   {
2516     try {
2517       result = (int)(arg1)->ReferenceCount();
2518     } catch (std::out_of_range& e) {
2519       {
2520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2521       };
2522     } catch (std::exception& e) {
2523       {
2524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2525       };
2526     } catch (...) {
2527       {
2528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2529       };
2530     }
2531   }
2532   jresult = result;
2533   return jresult;
2534 }
2535
2536
2537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
2538   void * jresult ;
2539   Dali::Any *result = 0 ;
2540
2541   {
2542     try {
2543       result = (Dali::Any *)new Dali::Any();
2544     } catch (std::out_of_range& e) {
2545       {
2546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2547       };
2548     } catch (std::exception& e) {
2549       {
2550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (...) {
2553       {
2554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2555       };
2556     }
2557   }
2558   jresult = (void *)result;
2559   return jresult;
2560 }
2561
2562
2563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
2564   Dali::Any *arg1 = (Dali::Any *) 0 ;
2565
2566   arg1 = (Dali::Any *)jarg1;
2567   {
2568     try {
2569       delete arg1;
2570     } catch (std::out_of_range& e) {
2571       {
2572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2573       };
2574     } catch (std::exception& e) {
2575       {
2576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2577       };
2578     } catch (...) {
2579       {
2580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2581       };
2582     }
2583   }
2584 }
2585
2586
2587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
2588   char *arg1 = (char *) 0 ;
2589
2590   arg1 = (char *)jarg1;
2591   {
2592     try {
2593       Dali::Any::AssertAlways((char const *)arg1);
2594     } catch (std::out_of_range& e) {
2595       {
2596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2597       };
2598     } catch (std::exception& e) {
2599       {
2600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2601       };
2602     } catch (...) {
2603       {
2604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2605       };
2606     }
2607   }
2608 }
2609
2610
2611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
2612   void * jresult ;
2613   Dali::Any *arg1 = 0 ;
2614   Dali::Any *result = 0 ;
2615
2616   arg1 = (Dali::Any *)jarg1;
2617   if (!arg1) {
2618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2619     return 0;
2620   }
2621   {
2622     try {
2623       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
2624     } catch (std::out_of_range& e) {
2625       {
2626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2627       };
2628     } catch (std::exception& e) {
2629       {
2630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2631       };
2632     } catch (...) {
2633       {
2634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2635       };
2636     }
2637   }
2638   jresult = (void *)result;
2639   return jresult;
2640 }
2641
2642
2643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
2644   void * jresult ;
2645   Dali::Any *arg1 = (Dali::Any *) 0 ;
2646   Dali::Any *arg2 = 0 ;
2647   Dali::Any *result = 0 ;
2648
2649   arg1 = (Dali::Any *)jarg1;
2650   arg2 = (Dali::Any *)jarg2;
2651   if (!arg2) {
2652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
2653     return 0;
2654   }
2655   {
2656     try {
2657       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2665       };
2666     } catch (...) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2669       };
2670     }
2671   }
2672   jresult = (void *)result;
2673   return jresult;
2674 }
2675
2676
2677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
2678   void * jresult ;
2679   Dali::Any *arg1 = (Dali::Any *) 0 ;
2680   std::type_info *result = 0 ;
2681
2682   arg1 = (Dali::Any *)jarg1;
2683   {
2684     try {
2685       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
2686     } catch (std::out_of_range& e) {
2687       {
2688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2689       };
2690     } catch (std::exception& e) {
2691       {
2692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (...) {
2695       {
2696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2697       };
2698     }
2699   }
2700   jresult = (void *)result;
2701   return jresult;
2702 }
2703
2704
2705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
2706   unsigned int jresult ;
2707   Dali::Any *arg1 = (Dali::Any *) 0 ;
2708   bool result;
2709
2710   arg1 = (Dali::Any *)jarg1;
2711   {
2712     try {
2713       result = (bool)((Dali::Any const *)arg1)->Empty();
2714     } catch (std::out_of_range& e) {
2715       {
2716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2717       };
2718     } catch (std::exception& e) {
2719       {
2720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2721       };
2722     } catch (...) {
2723       {
2724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2725       };
2726     }
2727   }
2728   jresult = result;
2729   return jresult;
2730 }
2731
2732
2733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
2734   void * jresult ;
2735   std::type_info *arg1 = 0 ;
2736   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
2737   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
2738   Dali::Any::AnyContainerBase *result = 0 ;
2739
2740   arg1 = (std::type_info *)jarg1;
2741   if (!arg1) {
2742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
2743     return 0;
2744   }
2745   arg2 = (Dali::Any::CloneFunc)jarg2;
2746   arg3 = (Dali::Any::DeleteFunc)jarg3;
2747   {
2748     try {
2749       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
2750     } catch (std::out_of_range& e) {
2751       {
2752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2753       };
2754     } catch (std::exception& e) {
2755       {
2756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (...) {
2759       {
2760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2761       };
2762     }
2763   }
2764   jresult = (void *)result;
2765   return jresult;
2766 }
2767
2768
2769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
2770   void * jresult ;
2771   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2772   std::type_info *result = 0 ;
2773
2774   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2775   {
2776     try {
2777       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
2778     } catch (std::out_of_range& e) {
2779       {
2780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2781       };
2782     } catch (std::exception& e) {
2783       {
2784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2785       };
2786     } catch (...) {
2787       {
2788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2789       };
2790     }
2791   }
2792   jresult = (void *)result;
2793   return jresult;
2794 }
2795
2796
2797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
2798   void * jresult ;
2799   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2800   ::std::type_info *result = 0 ;
2801
2802   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2803   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
2810   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2811   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
2812
2813   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2814   arg2 = (Dali::Any::CloneFunc)jarg2;
2815   if (arg1) (arg1)->mCloneFunc = arg2;
2816 }
2817
2818
2819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
2820   void * jresult ;
2821   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2822   Dali::Any::CloneFunc result;
2823
2824   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2825   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
2826   jresult = (void *)result;
2827   return jresult;
2828 }
2829
2830
2831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
2832   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2833   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
2834
2835   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2836   arg2 = (Dali::Any::DeleteFunc)jarg2;
2837   if (arg1) (arg1)->mDeleteFunc = arg2;
2838 }
2839
2840
2841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
2842   void * jresult ;
2843   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2844   Dali::Any::DeleteFunc result;
2845
2846   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2847   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
2848   jresult = (void *)result;
2849   return jresult;
2850 }
2851
2852
2853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
2854   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
2855
2856   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
2857   {
2858     try {
2859       delete arg1;
2860     } catch (std::out_of_range& e) {
2861       {
2862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2863       };
2864     } catch (std::exception& e) {
2865       {
2866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2867       };
2868     } catch (...) {
2869       {
2870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2871       };
2872     }
2873   }
2874 }
2875
2876
2877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
2878   Dali::Any *arg1 = (Dali::Any *) 0 ;
2879   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
2880
2881   arg1 = (Dali::Any *)jarg1;
2882   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
2883   if (arg1) (arg1)->mContainer = arg2;
2884 }
2885
2886
2887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
2888   void * jresult ;
2889   Dali::Any *arg1 = (Dali::Any *) 0 ;
2890   Dali::Any::AnyContainerBase *result = 0 ;
2891
2892   arg1 = (Dali::Any *)jarg1;
2893   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
2894   jresult = (void *)result;
2895   return jresult;
2896 }
2897
2898
2899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
2900   void * jresult ;
2901   Dali::Vector2 *result = 0 ;
2902
2903   {
2904     try {
2905       result = (Dali::Vector2 *)new Dali::Vector2();
2906     } catch (std::out_of_range& e) {
2907       {
2908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2909       };
2910     } catch (std::exception& e) {
2911       {
2912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (...) {
2915       {
2916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2917       };
2918     }
2919   }
2920   jresult = (void *)result;
2921   return jresult;
2922 }
2923
2924
2925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
2926   void * jresult ;
2927   float arg1 ;
2928   float arg2 ;
2929   Dali::Vector2 *result = 0 ;
2930
2931   arg1 = (float)jarg1;
2932   arg2 = (float)jarg2;
2933   {
2934     try {
2935       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
2936     } catch (std::out_of_range& e) {
2937       {
2938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2939       };
2940     } catch (std::exception& e) {
2941       {
2942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2943       };
2944     } catch (...) {
2945       {
2946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2947       };
2948     }
2949   }
2950   jresult = (void *)result;
2951   return jresult;
2952 }
2953
2954
2955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
2956   void * jresult ;
2957   float *arg1 = (float *) 0 ;
2958   Dali::Vector2 *result = 0 ;
2959
2960   arg1 = jarg1;
2961   {
2962     try {
2963       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
2964     } catch (std::out_of_range& e) {
2965       {
2966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2967       };
2968     } catch (std::exception& e) {
2969       {
2970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2971       };
2972     } catch (...) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2975       };
2976     }
2977   }
2978   jresult = (void *)result;
2979
2980
2981   return jresult;
2982 }
2983
2984
2985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
2986   void * jresult ;
2987   Dali::Vector3 *arg1 = 0 ;
2988   Dali::Vector2 *result = 0 ;
2989
2990   arg1 = (Dali::Vector3 *)jarg1;
2991   if (!arg1) {
2992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
2993     return 0;
2994   }
2995   {
2996     try {
2997       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
2998     } catch (std::out_of_range& e) {
2999       {
3000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3001       };
3002     } catch (std::exception& e) {
3003       {
3004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3005       };
3006     } catch (...) {
3007       {
3008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3009       };
3010     }
3011   }
3012   jresult = (void *)result;
3013   return jresult;
3014 }
3015
3016
3017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3018   void * jresult ;
3019   Dali::Vector4 *arg1 = 0 ;
3020   Dali::Vector2 *result = 0 ;
3021
3022   arg1 = (Dali::Vector4 *)jarg1;
3023   if (!arg1) {
3024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3025     return 0;
3026   }
3027   {
3028     try {
3029       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3030     } catch (std::out_of_range& e) {
3031       {
3032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3033       };
3034     } catch (std::exception& e) {
3035       {
3036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3037       };
3038     } catch (...) {
3039       {
3040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3041       };
3042     }
3043   }
3044   jresult = (void *)result;
3045   return jresult;
3046 }
3047
3048
3049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3050   void * jresult ;
3051   Dali::Vector2 *result = 0 ;
3052
3053   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3054   jresult = (void *)result;
3055   return jresult;
3056 }
3057
3058
3059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3060   void * jresult ;
3061   Dali::Vector2 *result = 0 ;
3062
3063   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3064   jresult = (void *)result;
3065   return jresult;
3066 }
3067
3068
3069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3070   void * jresult ;
3071   Dali::Vector2 *result = 0 ;
3072
3073   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3074   jresult = (void *)result;
3075   return jresult;
3076 }
3077
3078
3079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3080   void * jresult ;
3081   Dali::Vector2 *result = 0 ;
3082
3083   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3084   jresult = (void *)result;
3085   return jresult;
3086 }
3087
3088
3089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3090   void * jresult ;
3091   Dali::Vector2 *result = 0 ;
3092
3093   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3094   jresult = (void *)result;
3095   return jresult;
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3100   void * jresult ;
3101   Dali::Vector2 *result = 0 ;
3102
3103   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3104   jresult = (void *)result;
3105   return jresult;
3106 }
3107
3108
3109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3110   void * jresult ;
3111   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3112   float *arg2 = (float *) 0 ;
3113   Dali::Vector2 *result = 0 ;
3114
3115   arg1 = (Dali::Vector2 *)jarg1;
3116   arg2 = jarg2;
3117   {
3118     try {
3119       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3120     } catch (std::out_of_range& e) {
3121       {
3122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (std::exception& e) {
3125       {
3126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3127       };
3128     } catch (...) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3131       };
3132     }
3133   }
3134   jresult = (void *)result;