Merge "C# CustomView Implementation (C++ wrappers, manual bindings, C# wrappers)...
[platform/core/uifw/dali-toolkit.git] / 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;