Add .clang-format + auto formating by clang-format-11

Excute auto-formating test

AfterExternBlock: false

Change-Id: I9db243026c9f30a8a369f6a06dee3139d64b468b
Signed-off-by: Eunki, Hong <eunkiki.hong@samsung.com>

diff --git a/.clang-format b/.clang-format
new file mode 100644 (file)
index 0000000..7d18b03
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,97 @@
+---
+Language:        Cpp
+BasedOnStyle:  Google
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: true
+AlignEscapedNewlinesLeft: true
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: false
+  AfterStruct:     true
+  AfterUnion:      true
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+AllowAllConstructorInitializersOnNextLine : false
+ConstructorInitializerIndentWidth: 0
+ColumnLimit:     0
+CommentPragmas:  '^ IWYU pragma:'
+ContinuationIndentWidth: 2
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Preserve
+IncludeCategories:
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+  - Regex:           '^<.*'
+    Priority:        2
+  - Regex:           '.*'
+    Priority:        3
+SpaceBeforeCtorInitializerColon: false
+IndentCaseLabels: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: '^DALI_ENUM_TO_STRING_TABLE_BEGIN'
+MacroBlockEnd:   'DALI_ENUM_TO_STRING_TABLE_END'
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: Never
+SpaceInEmptyParentheses: false
+SpacesInConditionalStatement : false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceAfterTemplateKeyword: false
+Standard:        Auto
+TabWidth:        2
+UseTab:          Never
+...

diff --git a/dali-csharp-binder/src/actor-wrap.cpp b/dali-csharp-binder/src/actor-wrap.cpp
index e79b400..8e527f3 100644 (file)
--- a/dali-csharp-binder/src/actor-wrap.cpp
+++ b/dali-csharp-binder/src/actor-wrap.cpp
@@ -23,3227 +23,3569 @@
 
 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
 
-
 // SWIGINTERN - the relevant parts of the generated code can be seen the below.
 
-SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
-         return self->Empty();
-      }
-SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
-        return self->GetConnectionCount();
-      }
-SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
-        self->Connect( func );
-      }
-SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
-        self->Disconnect( func );
-      }
-SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
-        return self->Emit( arg1, arg2 );
-      }
-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){
-         return self->Empty();
-      }
-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){
-        return self->GetConnectionCount();
-      }
-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 &)){
-        self->Connect( func );
-      }
-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 &)){
-        self->Disconnect( func );
-      }
-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){
-        return self->Emit( arg1, arg2 );
-      }
-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){
-         return self->Empty();
-      }
-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){
-        return self->GetConnectionCount();
-      }
-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 &)){
-        self->Connect( func );
-      }
-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 &)){
-        self->Disconnect( func );
-      }
-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){
-        return self->Emit( arg1, arg2 );
-      }
-SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
-         return self->Empty();
-      }
-SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
-        return self->GetConnectionCount();
-      }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
-          self->Connect( func );
-      }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
-          self->Disconnect( func );
-      }
-SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
-          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
-/*@SWIG@*/ self->Emit( arg );
-      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)> const* self)
+{
+  return self->Empty();
+}
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)> const* self)
+{
+  return self->GetConnectionCount();
+}
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&))
+{
+  self->Connect(func);
+}
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* self, bool (*func)(Dali::Actor, Dali::TouchEvent const&))
+{
+  self->Disconnect(func);
+}
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* self, Dali::Actor arg1, Dali::TouchEvent const& arg2)
+{
+  return self->Emit(arg1, arg2);
+}
+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)
+{
+  return self->Empty();
+}
+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)
+{
+  return self->GetConnectionCount();
+}
+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&))
+{
+  self->Connect(func);
+}
+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&))
+{
+  self->Disconnect(func);
+}
+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)
+{
+  return self->Emit(arg1, arg2);
+}
+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)
+{
+  return self->Empty();
+}
+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)
+{
+  return self->GetConnectionCount();
+}
+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&))
+{
+  self->Connect(func);
+}
+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&))
+{
+  self->Disconnect(func);
+}
+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)
+{
+  return self->Emit(arg1, arg2);
+}
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal<void(Dali::Actor)> const* self)
+{
+  return self->Empty();
+}
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal<void(Dali::Actor)> const* self)
+{
+  return self->GetConnectionCount();
+}
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal<void(Dali::Actor)>* self, void (*func)(Dali::Actor))
+{
+  self->Connect(func);
+}
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal<void(Dali::Actor)>* self, void (*func)(Dali::Actor))
+{
+  self->Disconnect(func);
+}
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal<void(Dali::Actor)>* self, Dali::Actor arg)
+{
+  /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+  /*@SWIG@*/ self->Emit(arg);
+}
 
 using namespace Dali;
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 // Property
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::PARENT_ORIGIN;
+  result  = (int)Dali::Actor::Property::PARENT_ORIGIN;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
+  result  = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
+  result  = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
+  result  = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::ANCHOR_POINT;
+  result  = (int)Dali::Actor::Property::ANCHOR_POINT;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
+  result  = (int)Dali::Actor::Property::ANCHOR_POINT_X;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
+  result  = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
+  result  = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SIZE;
+  result  = (int)Dali::Actor::Property::SIZE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SIZE_WIDTH;
+  result  = (int)Dali::Actor::Property::SIZE_WIDTH;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SIZE_HEIGHT;
+  result  = (int)Dali::Actor::Property::SIZE_HEIGHT;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SIZE_DEPTH;
+  result  = (int)Dali::Actor::Property::SIZE_DEPTH;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::POSITION;
+  result  = (int)Dali::Actor::Property::POSITION;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::POSITION_X;
+  result  = (int)Dali::Actor::Property::POSITION_X;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::POSITION_Y;
+  result  = (int)Dali::Actor::Property::POSITION_Y;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::POSITION_Z;
+  result  = (int)Dali::Actor::Property::POSITION_Z;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_POSITION;
+  result  = (int)Dali::Actor::Property::WORLD_POSITION;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_POSITION_X;
+  result  = (int)Dali::Actor::Property::WORLD_POSITION_X;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
+  result  = (int)Dali::Actor::Property::WORLD_POSITION_Y;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
+  result  = (int)Dali::Actor::Property::WORLD_POSITION_Z;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::ORIENTATION;
+  result  = (int)Dali::Actor::Property::ORIENTATION;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
+  result  = (int)Dali::Actor::Property::WORLD_ORIENTATION;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SCALE;
+  result  = (int)Dali::Actor::Property::SCALE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SCALE_X;
+  result  = (int)Dali::Actor::Property::SCALE_X;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SCALE_Y;
+  result  = (int)Dali::Actor::Property::SCALE_Y;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SCALE_Z;
+  result  = (int)Dali::Actor::Property::SCALE_Z;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_SCALE;
+  result  = (int)Dali::Actor::Property::WORLD_SCALE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::VISIBLE;
+  result  = (int)Dali::Actor::Property::VISIBLE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::COLOR;
+  result  = (int)Dali::Actor::Property::COLOR;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::COLOR_RED;
+  result  = (int)Dali::Actor::Property::COLOR_RED;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::COLOR_GREEN;
+  result  = (int)Dali::Actor::Property::COLOR_GREEN;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::COLOR_BLUE;
+  result  = (int)Dali::Actor::Property::COLOR_BLUE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::COLOR_ALPHA;
+  result  = (int)Dali::Actor::Property::COLOR_ALPHA;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_COLOR;
+  result  = (int)Dali::Actor::Property::WORLD_COLOR;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WORLD_MATRIX;
+  result  = (int)Dali::Actor::Property::WORLD_MATRIX;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::NAME;
+  result  = (int)Dali::Actor::Property::NAME;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SENSITIVE;
+  result  = (int)Dali::Actor::Property::SENSITIVE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_USER_INTERACTION_ENABLED_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
+  result  = (int)Dali::DevelActor::Property::USER_INTERACTION_ENABLED;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
+  result  = (int)Dali::Actor::Property::LEAVE_REQUIRED;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
+  result  = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::INHERIT_SCALE;
+  result  = (int)Dali::Actor::Property::INHERIT_SCALE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::COLOR_MODE;
+  result  = (int)Dali::Actor::Property::COLOR_MODE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::DRAW_MODE;
+  result  = (int)Dali::Actor::Property::DRAW_MODE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
+  result  = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
+  result  = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
+  result  = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
+  result  = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
+  result  = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
+  result  = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::PADDING;
+  result  = (int)Dali::Actor::Property::PADDING;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::MINIMUM_SIZE;
+  result  = (int)Dali::Actor::Property::MINIMUM_SIZE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
+  result  = (int)Dali::Actor::Property::MAXIMUM_SIZE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::INHERIT_POSITION;
+  result  = (int)Dali::Actor::Property::INHERIT_POSITION;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::CLIPPING_MODE;
+  result  = (int)Dali::Actor::Property::CLIPPING_MODE;
   jresult = (int)result;
   return jresult;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_UPDATE_AREA_HINT_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
+  result  = (int)Dali::Actor::Property::UPDATE_AREA_HINT;
   jresult = (int)result;
   return jresult;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
-
+SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get()
+{
   return Dali::Actor::Property::OPACITY;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
-
+SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get()
+{
   return Dali::Actor::Property::SCREEN_POSITION;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
-
+SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get()
+{
   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get()
+{
   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get()
+{
   return Dali::Actor::Property::LAYOUT_DIRECTION;
 }
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get() {
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CULLED_get()
+{
   return Dali::Actor::Property::CULLED;
 }
 
-
 // Creation
 
-SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
-    return (Dali::Handle *)jarg1;
+SWIGEXPORT Dali::Handle* SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor* jarg1)
+{
+  return (Dali::Handle*)jarg1;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
-  void * jresult ;
-  Dali::Actor::Property *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor_Property()
+{
+  void*                  jresult;
+  Dali::Actor::Property* result = 0;
 
   {
-    try {
-      result = (Dali::Actor::Property *)new Dali::Actor::Property();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::Property*)new Dali::Actor::Property();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void* jarg1)
+{
+  Dali::Actor::Property* arg1 = (Dali::Actor::Property*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
-  Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
-
-  arg1 = (Dali::Actor::Property *)jarg1;
+  arg1 = (Dali::Actor::Property*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
-  void * jresult ;
-  Dali::Actor *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0()
+{
+  void*        jresult;
+  Dali::Actor* result = 0;
 
   {
-    try {
-      result = (Dali::Actor *)new Dali::Actor();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor*)new Dali::Actor();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
-  void * jresult ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_New()
+{
+  void*       jresult;
   Dali::Actor result;
 
   {
-    try {
+    try
+    {
       result = Dali::Actor::New();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Actor((const Dali::Actor &)result);
+  jresult = new Dali::Actor((const Dali::Actor&)result);
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_DownCast(void* jarg1)
+{
+  void*             jresult;
+  Dali::BaseHandle  arg1;
+  Dali::BaseHandle* argp1;
+  Dali::Actor       result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
-  void * jresult ;
-  Dali::BaseHandle arg1 ;
-  Dali::BaseHandle *argp1 ;
-  Dali::Actor result;
-
-  argp1 = (Dali::BaseHandle *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::BaseHandle*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
     return 0;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       result = Dali::Actor::DownCast(arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Actor((const Dali::Actor &)result);
+  jresult = new Dali::Actor((const Dali::Actor&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void* jarg1)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void* jarg1)
+{
+  void*        jresult;
+  Dali::Actor* arg1   = 0;
+  Dali::Actor* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = 0 ;
-  Dali::Actor *result = 0 ;
-
-  arg1 = (Dali::Actor *)jarg1;
-  if (!arg1) {
+  arg1 = (Dali::Actor*)jarg1;
+  if(!arg1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor*)new Dali::Actor((Dali::Actor const&)*arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_Assign(void* jarg1, void* jarg2)
+{
+  void*        jresult;
+  Dali::Actor* arg1   = (Dali::Actor*)0;
+  Dali::Actor* arg2   = 0;
+  Dali::Actor* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor *arg2 = 0 ;
-  Dali::Actor *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  if (!jarg2) {
+  if(!jarg2)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Actor *)jarg2;
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Actor*)jarg2;
   {
-    try {
-      result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor*)&(arg1)->operator=((Dali::Actor const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-
 // Method
 
-SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
-  char * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  std::string *result = 0 ;
-  std::string name = "";
+SWIGEXPORT char* SWIGSTDCALL CSharp_Dali_Actor_GetName(void* jarg1)
+{
+  char*        jresult;
+  Dali::Actor* arg1   = (Dali::Actor*)0;
+  std::string* result = 0;
+  std::string  name   = "";
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
-      result = (std::string *) &name;
+    try
+    {
+      name    = ((Dali::Actor const*)arg1)->GetProperty<std::string>(Dali::Actor::Property::NAME);
+      result  = (std::string*)&name;
       jresult = SWIG_csharp_string_callback(result->c_str());
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void* jarg1, char* jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  std::string* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  std::string *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  if (!jarg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  if(!jarg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
-    return ;
+    return;
   }
   std::string arg2_str(jarg2);
   arg2 = &arg2_str;
   {
-    try {
-      (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Dali::Actor::Property::NAME, (std::string const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 
-
   //argout typemap for const std::string&
-
 }
 
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void* jarg1)
+{
+  unsigned int jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
   unsigned int result;
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
 
-  if(!arg1) {
+  if(!arg1)
+  {
     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
     return -1;
   }
 
   {
-    try {
-      result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (unsigned int)((Dali::Actor const*)arg1)->GetProperty<int>(Actor::Property::ID);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::IS_ROOT);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::IS_LAYER);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void* jarg1)
+{
+  void*        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  Dali::Layer  result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Layer result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
+    try
+    {
       result = (arg1)->GetLayer();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Layer((const Dali::Layer &)result);
+  jresult = new Dali::Layer((const Dali::Layer&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void* jarg1, void* jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  Dali::Actor  arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
-  if (!jarg2) {
+  if(!jarg2)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = *((Dali::Actor *)jarg2);
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = *((Dali::Actor*)jarg2);
   {
-    try {
+    try
+    {
       (arg1)->Add(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void* jarg1, void* jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  Dali::Actor  arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
-  if (!jarg2) {
+  if(!jarg2)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg2 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = *((Dali::Actor *)jarg2);
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = *((Dali::Actor*)jarg2);
   {
-    try {
+    try
+    {
       (arg1)->Remove(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void* jarg1)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->Unparent();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void* jarg1)
+{
+  unsigned int jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
   unsigned int result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (unsigned int)((Dali::Actor const*)arg1)->GetChildCount();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void* jarg1, unsigned int jarg2)
+{
+  void*        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  unsigned int arg2;
+  Dali::Actor  result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  unsigned int arg2 ;
-  Dali::Actor result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (unsigned int)jarg2;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetChildAt(arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Actor((const Dali::Actor &)result);
+  jresult = new Dali::Actor((const Dali::Actor&)result);
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void* jarg1, char* jarg2)
+{
+  void*        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  std::string* arg2 = 0;
+  Dali::Actor  result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  std::string *arg2 = 0 ;
-  Dali::Actor result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  if (!jarg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  if(!jarg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
     return 0;
   }
   std::string arg2_str(jarg2);
   arg2 = &arg2_str;
   {
-    try {
-      result = (arg1)->FindChildByName((std::string const &)*arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (arg1)->FindChildByName((std::string const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Actor((const Dali::Actor &)result);
+  jresult = new Dali::Actor((const Dali::Actor&)result);
 
   //argout typemap for const std::string&
 
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void* jarg1, unsigned int jarg2)
+{
+  void*        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  unsigned int arg2;
+  Dali::Actor  result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  unsigned int arg2 ;
-  Dali::Actor result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (unsigned int)jarg2;
   {
-    try {
+    try
+    {
       result = (arg1)->FindChildById(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Actor((const Dali::Actor &)result);
+  jresult = new Dali::Actor((const Dali::Actor&)result);
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetParent(void* jarg1)
+{
+  void*        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  Dali::Actor  result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetParent();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetParent();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Actor((const Dali::Actor &)result);
+  jresult = new Dali::Actor((const Dali::Actor&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::PARENT_ORIGIN, (Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::ANCHOR_POINT, (Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void* jarg1, float jarg2, float jarg3)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        arg3;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float arg3 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   arg3 = (float)jarg3;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector2(arg2, arg3));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        arg3;
+  float        arg4;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float arg3 ;
-  float arg4 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   arg3 = (float)jarg3;
   arg4 = (float)jarg4;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SIZE, Dali::Vector3(arg2, arg3, arg4));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector2* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector2 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector2 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector2*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector2 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SIZE, (Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetTargetSize();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetTargetSize();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::SIZE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetNaturalSize();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetNaturalSize();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void* jarg1, float jarg2, float jarg3)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        arg3;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float arg3 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   arg3 = (float)jarg3;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector2(arg2, arg3));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        arg3;
+  float        arg4;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float arg3 ;
-  float arg4 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   arg3 = (float)jarg3;
   arg4 = (float)jarg4;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::POSITION, Dali::Vector3(arg2, arg3, arg4));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::POSITION, (Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void* jarg1, float jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::POSITION_X, (arg2));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void* jarg1, float jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::POSITION_Y, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void* jarg1, float jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::POSITION_Z, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->TranslateBy((Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::POSITION);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
+    try
+    {
       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void* jarg1, void* jarg2, void* jarg3)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Degree*  arg2 = 0;
+  Dali::Vector3* arg3 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Degree *arg2 = 0 ;
-  Dali::Vector3 *arg3 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Degree *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Degree*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
-    return ;
+    return;
   }
-  arg3 = (Dali::Vector3 *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::Vector3*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void* jarg1, void* jarg2, void* jarg3)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Radian*  arg2 = 0;
+  Dali::Vector3* arg3 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Radian *arg2 = 0 ;
-  Dali::Vector3 *arg3 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Radian *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Radian*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
-    return ;
+    return;
   }
-  arg3 = (Dali::Vector3 *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::Vector3*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::ORIENTATION, Quaternion((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void* jarg1, void* jarg2)
+{
+  Dali::Actor*      arg1 = (Dali::Actor*)0;
+  Dali::Quaternion* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Quaternion *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Quaternion *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Quaternion*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::ORIENTATION, (Dali::Quaternion const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void* jarg1, void* jarg2, void* jarg3)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Degree*  arg2 = 0;
+  Dali::Vector3* arg3 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Degree *arg2 = 0 ;
-  Dali::Vector3 *arg3 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Degree *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Degree*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
-    return ;
+    return;
   }
-  arg3 = (Dali::Vector3 *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::Vector3*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->RotateBy((Dali::Degree const&)*arg2, (Dali::Vector3 const&)*arg3);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void* jarg1, void* jarg2, void* jarg3)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Radian*  arg2 = 0;
+  Dali::Vector3* arg3 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Radian *arg2 = 0 ;
-  Dali::Vector3 *arg3 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Radian *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Radian*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
-    return ;
+    return;
   }
-  arg3 = (Dali::Vector3 *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::Vector3*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->RotateBy((Dali::Radian const&)*arg2, (Dali::Vector3 const&)*arg3);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void* jarg1, void* jarg2)
+{
+  Dali::Actor*      arg1 = (Dali::Actor*)0;
+  Dali::Quaternion* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Quaternion *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Quaternion *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Quaternion*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->RotateBy((Dali::Quaternion const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void* jarg1)
+{
+  void*            jresult;
+  Dali::Actor*     arg1 = (Dali::Actor*)0;
   Dali::Quaternion result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
+  jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::INHERIT_ORIENTATION, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::INHERIT_ORIENTATION);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void* jarg1)
+{
+  void*            jresult;
+  Dali::Actor*     arg1 = (Dali::Actor*)0;
   Dali::Quaternion result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
+  jresult = new Dali::Quaternion((const Dali::Quaternion&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void* jarg1, float jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SCALE, arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SCALE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void* jarg1, float jarg2, float jarg3, float jarg4)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        arg3;
+  float        arg4;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float arg3 ;
-  float arg4 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   arg3 = (float)jarg3;
   arg4 = (float)jarg4;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SCALE, Vector3(arg2, arg3, arg4));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SCALE, (Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->ScaleBy((Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::SCALE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::INHERIT_SCALE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::INHERIT_SCALE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void* jarg1)
+{
+  void*        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
   Dali::Matrix result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Matrix((const Dali::Matrix &)result);
+  jresult = new Dali::Matrix((const Dali::Matrix&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void* jarg1)
+{
+  Dali::Actor  arg1;
+  Dali::Actor* argp1;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       arg1.Raise();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void* jarg1)
+{
+  Dali::Actor  arg1;
+  Dali::Actor* argp1;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       arg1.Lower();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void* jarg1)
+{
+  Dali::Actor  arg1;
+  Dali::Actor* argp1;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       arg1.RaiseToTop();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void* jarg1)
+{
+  Dali::Actor  arg1;
+  Dali::Actor* argp1;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       arg1.LowerToBottom();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
-  Dali::Actor arg1 ;
-  Dali::Actor arg2 ;
-  Dali::Actor *argp1 ;
-  Dali::Actor *argp2 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void* jarg1, void* jarg2)
+{
+  Dali::Actor  arg1;
+  Dali::Actor  arg2;
+  Dali::Actor* argp1;
+  Dali::Actor* argp2;
 
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
-  arg1 = *argp1;
-  argp2 = (Dali::Actor *)jarg2;
-  if (!argp2) {
+  arg1  = *argp1;
+  argp2 = (Dali::Actor*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
+    try
+    {
       arg1.RaiseAbove(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void* jarg1, void* jarg2)
+{
+  Dali::Actor  arg1;
+  Dali::Actor  arg2;
+  Dali::Actor* argp1;
+  Dali::Actor* argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
-  Dali::Actor arg1 ;
-  Dali::Actor arg2 ;
-  Dali::Actor *argp1 ;
-  Dali::Actor *argp2 ;
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
-  arg1 = *argp1;
-  argp2 = (Dali::Actor *)jarg2;
-  if (!argp2) {
+  arg1  = *argp1;
+  argp2 = (Dali::Actor*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
+    try
+    {
       arg1.LowerBelow(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::VISIBLE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetCurrentProperty<bool>(Actor::Property::VISIBLE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void* jarg1, float jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::OPACITY, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void* jarg1)
+{
+  float        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        result;
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
-  float jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (float)((Dali::Actor const*)arg1)->GetCurrentProperty<float>(Actor::Property::OPACITY);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector4* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector4 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector4 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector4*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::COLOR, (Dali::Vector4 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector4 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector4>(Actor::Property::COLOR);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+  jresult = new Dali::Vector4((const Dali::Vector4&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void* jarg1, int jarg2)
+{
+  Dali::Actor*    arg1 = (Dali::Actor*)0;
+  Dali::ColorMode arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::ColorMode arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (Dali::ColorMode)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::COLOR_MODE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
-  int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void* jarg1)
+{
+  int             jresult;
+  Dali::Actor*    arg1 = (Dali::Actor*)0;
   Dali::ColorMode result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::ColorMode)((Dali::Actor const*)arg1)->GetProperty<ColorMode>(Actor::Property::COLOR_MODE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector4 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector4((const Dali::Vector4 &)result);
+  jresult = new Dali::Vector4((const Dali::Vector4&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void* jarg1, int jarg2)
+{
+  Dali::Actor*         arg1 = (Dali::Actor*)0;
+  Dali::DrawMode::Type arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::DrawMode::Type arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (Dali::DrawMode::Type)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::DRAW_MODE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
-  int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void* jarg1)
+{
+  int                  jresult;
+  Dali::Actor*         arg1 = (Dali::Actor*)0;
   Dali::DrawMode::Type result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::DrawMode::Type)((Dali::Actor const*)arg1)->GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (int)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SENSITIVE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::SENSITIVE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void* jarg1, float* jarg2, float* jarg3, float jarg4, float jarg5)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float*       arg2 = 0;
+  float*       arg3 = 0;
+  float        arg4;
+  float        arg5;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float *arg2 = 0 ;
-  float *arg3 = 0 ;
-  float arg4 ;
-  float arg5 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (float *)jarg2;
-  arg3 = (float *)jarg3;
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (float*)jarg2;
+  arg3 = (float*)jarg3;
   arg4 = (float)jarg4;
   arg5 = (float)jarg5;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->ScreenToLocal(*arg2, *arg3, arg4, arg5);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::LEAVE_REQUIRED, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::LEAVE_REQUIRED);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void * actor, bool keyboardFocusableChildren) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusableChildren(void* actor, bool keyboardFocusableChildren)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
 
-  if (!actor) {
+  if(!actor)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)actor;
+  arg1 = (Dali::Actor*)actor;
   {
-    try {
-      (arg1)->SetProperty( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN, keyboardFocusableChildren);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void* actor)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_AreChildrenKeyBoardFocusable(void * actor) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!actor) {
+  if(!actor)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "actor is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)actor;
+  arg1 = (Dali::Actor*)actor;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(DevelActor::Property::KEYBOARD_FOCUSABLE_CHILDREN);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
   return result;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void * jarg1, bool jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool arg2 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetTouchFocusable(void* jarg1, bool jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         arg2;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( DevelActor::Property::TOUCH_FOCUSABLE, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(DevelActor::Property::TOUCH_FOCUSABLE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void* jarg1)
+{
+  bool         jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Actor_IsTouchFocusable(void * jarg1) {
-  bool jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  bool result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( DevelActor::Property::TOUCH_FOCUSABLE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Actor const*)arg1)->GetProperty<bool>(DevelActor::Property::TOUCH_FOCUSABLE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::ResizePolicy::Type arg2 ;
-  Dali::Dimension::Type arg3 ;
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void* jarg1, int jarg2, int jarg3)
+{
+  Dali::Actor*             arg1 = (Dali::Actor*)0;
+  Dali::ResizePolicy::Type arg2;
+  Dali::Dimension::Type    arg3;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (Dali::ResizePolicy::Type)jarg2;
   arg3 = (Dali::Dimension::Type)jarg3;
   {
-    try {
-      (arg1)->SetResizePolicy(arg2,arg3);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetResizePolicy(arg2, arg3);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
-  int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Dimension::Type arg2 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void* jarg1, int jarg2)
+{
+  int                      jresult;
+  Dali::Actor*             arg1 = (Dali::Actor*)0;
+  Dali::Dimension::Type    arg2;
   Dali::ResizePolicy::Type result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (Dali::Dimension::Type)jarg2;
   {
-    try {
-      result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::ResizePolicy::Type)((Dali::Actor const*)arg1)->GetResizePolicy(arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (int)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void* jarg1, int jarg2)
+{
+  Dali::Actor*                arg1 = (Dali::Actor*)0;
+  Dali::SizeScalePolicy::Type arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::SizeScalePolicy::Type arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SIZE_SCALE_POLICY, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
-  int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void* jarg1)
+{
+  int                         jresult;
+  Dali::Actor*                arg1 = (Dali::Actor*)0;
   Dali::SizeScalePolicy::Type result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::SizeScalePolicy::Type)((Dali::Actor const*)arg1)->GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (int)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector3* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector3 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector3 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector3*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector3 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Actor const*)arg1)->GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector3((const Dali::Vector3 &)result);
+  jresult = new Dali::Vector3((const Dali::Vector3&)result);
   return jresult;
 }
 
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void* jarg1, float jarg2)
+{
+  float        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        result;
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
-  float jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
+    try
+    {
       result = (float)(arg1)->GetHeightForWidth(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void* jarg1, float jarg2)
+{
+  float        jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  float        arg2;
+  float        result;
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
-  float jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  float arg2 ;
-  float result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (float)jarg2;
   {
-    try {
+    try
+    {
       result = (float)(arg1)->GetWidthForHeight(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void* jarg1, int jarg2)
+{
+  float                 jresult;
+  Dali::Actor*          arg1 = (Dali::Actor*)0;
+  Dali::Dimension::Type arg2;
+  float                 result;
 
-SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
-  float jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Dimension::Type arg2 ;
-  float result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (Dali::Dimension::Type)jarg2;
   {
-    try {
-      result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (float)((Dali::Actor const*)arg1)->GetRelayoutSize(arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Padding* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Padding *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Padding *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Padding*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::PADDING, (Dali::Padding const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Padding* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Padding *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Padding *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Padding*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      *arg2 = ((Dali::Actor const*)arg1)->GetProperty<Vector4>(Actor::Property::PADDING);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector2* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector2 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector2 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector2*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::MINIMUM_SIZE, (Dali::Vector2 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector2 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (arg1)->GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+  jresult = new Dali::Vector2((const Dali::Vector2&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void* jarg1, void* jarg2)
+{
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  Dali::Vector2* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Vector2 *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Vector2 *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Vector2*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
-      (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Actor::Property::MAXIMUM_SIZE, (Dali::Vector2 const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void* jarg1)
+{
+  void*         jresult;
+  Dali::Actor*  arg1 = (Dali::Actor*)0;
   Dali::Vector2 result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (arg1)->GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Vector2((const Dali::Vector2 &)result);
+  jresult = new Dali::Vector2((const Dali::Vector2&)result);
   return jresult;
 }
 
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void* jarg1)
+{
+  int          jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  int          result;
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
-  int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  int result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
-      Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result             = (int)(arg1)->GetProperty<int>(Actor::Property::HIERARCHY_DEPTH);
+      Dali::Actor parent = ((Dali::Actor const*)arg1)->GetParent();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void* jarg1, void* jarg2)
+{
+  unsigned int    jresult;
+  Dali::Actor*    arg1 = (Dali::Actor*)0;
+  Dali::Renderer* arg2 = 0;
+  unsigned int    result;
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
-  unsigned int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Renderer *arg2 = 0 ;
-  unsigned int result;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Renderer *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Renderer*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
     return 0;
   }
   {
-    try {
+    try
+    {
       result = (unsigned int)(arg1)->AddRenderer(*arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void* jarg1)
+{
+  unsigned int jresult;
+  Dali::Actor* arg1 = (Dali::Actor*)0;
   unsigned int result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (unsigned int)((Dali::Actor const*)arg1)->GetRendererCount();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  unsigned int arg2 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void* jarg1, unsigned int jarg2)
+{
+  void*          jresult;
+  Dali::Actor*   arg1 = (Dali::Actor*)0;
+  unsigned int   arg2;
   Dali::Renderer result;
 
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (unsigned int)jarg2;
   {
-    try {
+    try
+    {
       result = (arg1)->GetRendererAt(arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Renderer((const Dali::Renderer &)result);
+  jresult = new Dali::Renderer((const Dali::Renderer&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void* jarg1, void* jarg2)
+{
+  Dali::Actor*    arg1 = (Dali::Actor*)0;
+  Dali::Renderer* arg2 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Renderer *arg2 = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
-  arg2 = (Dali::Renderer *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Actor*)jarg1;
+  arg2 = (Dali::Renderer*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
+    try
+    {
       (arg1)->RemoveRenderer(*arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void* jarg1, unsigned int jarg2)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  unsigned int arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  unsigned int arg2 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
-    return ;
+    return;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   arg2 = (unsigned int)jarg2;
   {
-    try {
+    try
+    {
       (arg1)->RemoveRenderer(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void* jarg1, bool jarg2)
+{
+  Dali::Actor  arg1;
+  bool         arg2;
+  Dali::Actor* argp1 = (Dali::Actor*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetNeedGesturePropagation(void * jarg1, bool jarg2) {
-  Dali::Actor arg1 ;
-  bool arg2;
-  Dali::Actor *argp1 = (Dali::Actor *) 0 ;
-
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return;
   }
   arg1 = *argp1;
   arg2 = jarg2;
   {
-    try {
+    try
+    {
       Dali::DevelActor::SetNeedGesturePropagation(arg1, arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
   return;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void * actor) {
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 = (Dali::Actor *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void* actor)
+{
+  Dali::Actor       arg1;
+  Dali::Actor*      argp1 = (Dali::Actor*)0;
   Dali::Rect<float> result;
 
-  argp1 = (Dali::Actor *)actor;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)actor;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       result = Dali::DevelActor::CalculateScreenExtents(arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   // Note: The float type Rectangle class is not ready yet.
@@ -3252,758 +3594,841 @@ SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_CalculateScreenExtents(void * ac
   return new Dali::Vector4(result.x, result.y, result.width, result.height);
 }
 
-
-SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  arg1 = (Dali::Actor *)jarg1;
-  Rect<int> arg2 = Rect(jarg2, jarg3, jarg4, jarg5);
+SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_SetTouchAreaOffset(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  arg1              = (Dali::Actor*)jarg1;
+  Rect<int> arg2    = Rect(jarg2, jarg3, jarg4, jarg5);
   {
-    try {
-      (arg1)->SetProperty( Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Dali::DevelActor::Property::TOUCH_AREA_OFFSET, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
-SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void * jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5) {
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  arg1 = (Dali::Actor *)jarg1;
+SWIGEXPORT void SWIGSTDCALL CSharp_DevelActor_Property_GetTouchAreaOffset(void* jarg1, int* jarg2, int* jarg3, int* jarg4, int* jarg5)
+{
+  Dali::Actor* arg1 = (Dali::Actor*)0;
+  arg1              = (Dali::Actor*)jarg1;
 
   Rect<int32_t> result;
   {
-    try {
-      result = (arg1)->GetProperty<Rect<int32_t>>( Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
+    try
+    {
+      result = (arg1)->GetProperty<Rect<int32_t>>(Dali::DevelActor::Property::TOUCH_AREA_OFFSET);
       *jarg2 = result.left;
       *jarg3 = result.right;
       *jarg4 = result.bottom;
       *jarg5 = result.top;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void* jarg1)
+{
+  Dali::Actor* arg1 = 0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
-  Dali::Actor *arg1 = 0 ;
-
-  arg1 = (Dali::Actor *)jarg1;
-  if (!arg1) {
+  arg1 = (Dali::Actor*)jarg1;
+  if(!arg1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
-    return ;
+    return;
   }
   {
-    try {
+    try
+    {
       Dali::UnparentAndReset(*arg1);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
 // Signals
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 ;
-  Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void* jarg1)
+{
+  void*                                          jresult;
+  Dali::Actor                                    arg1;
+  Dali::Actor*                                   argp1;
+  Dali::DevelActor::VisibilityChangedSignalType* result = 0;
 
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg1 = *argp1;
   {
-    try {
-      result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::DevelActor::VisibilityChangedSignalType*)&Dali::DevelActor::VisibilityChangedSignal(arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void* jarg1)
+{
+  void*                                          jresult;
+  Dali::Actor*                                   arg1;
+  Dali::Actor::LayoutDirectionChangedSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 ;
-  Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
-
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::LayoutDirectionChangedSignalType*)&(arg1)->LayoutDirectionChangedSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void* jarg1)
+{
+  void*                              jresult;
+  Dali::Actor                        arg1;
+  Dali::Actor*                       argp1  = (Dali::Actor*)0;
+  Dali::Actor::TouchEventSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HitTestResultSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 = (Dali::Actor *) 0 ;
-  Dali::Actor::TouchEventSignalType *result = 0 ;
-
-
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg1 = *argp1;
   {
-    try {
-      result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::HitTestResultSignal(arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::TouchEventSignalType*)&Dali::DevelActor::HitTestResultSignal(arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor arg1 ;
-  Dali::Actor *argp1 = (Dali::Actor *) 0 ;
-  Dali::Actor::TouchEventSignalType *result = 0 ;
-
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_InterceptTouchSignal(void* jarg1)
+{
+  void*                              jresult;
+  Dali::Actor                        arg1;
+  Dali::Actor*                       argp1  = (Dali::Actor*)0;
+  Dali::Actor::TouchEventSignalType* result = 0;
 
-  argp1 = (Dali::Actor *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::Actor*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg1 = *argp1;
   {
-    try {
-      result = (Dali::Actor::TouchEventSignalType *) &Dali::DevelActor::InterceptTouchedSignal(arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::TouchEventSignalType*)&Dali::DevelActor::InterceptTouchedSignal(arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void* jarg1)
+{
+  void*                              jresult;
+  Dali::Actor*                       arg1   = (Dali::Actor*)0;
+  Dali::Actor::TouchEventSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor::TouchEventSignalType *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchedSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::TouchEventSignalType*)&(arg1)->TouchedSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void* jarg1)
+{
+  void*                         jresult;
+  Dali::Actor*                  arg1   = (Dali::Actor*)0;
+  Dali::Actor::HoverSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor::HoverSignalType *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::HoverSignalType*)&(arg1)->HoveredSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void* jarg1)
+{
+  void*                              jresult;
+  Dali::Actor*                       arg1   = (Dali::Actor*)0;
+  Dali::Actor::WheelEventSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor::WheelEventSignalType *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::WheelEventSignalType*)&(arg1)->WheelEventSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void* jarg1)
+{
+  void*                           jresult;
+  Dali::Actor*                    arg1   = (Dali::Actor*)0;
+  Dali::Actor::OnSceneSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor::OnSceneSignalType *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::OnSceneSignalType*)&(arg1)->OnSceneSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void* jarg1)
+{
+  void*                            jresult;
+  Dali::Actor*                     arg1   = (Dali::Actor*)0;
+  Dali::Actor::OffSceneSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor::OffSceneSignalType *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::OffSceneSignalType*)&(arg1)->OffSceneSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void* jarg1)
+{
+  void*                              jresult;
+  Dali::Actor*                       arg1   = (Dali::Actor*)0;
+  Dali::Actor::OnRelayoutSignalType* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
-  void * jresult ;
-  Dali::Actor *arg1 = (Dali::Actor *) 0 ;
-  Dali::Actor::OnRelayoutSignalType *result = 0 ;
-
-  if (!jarg1) {
+  if(!jarg1)
+  {
     SWIG_EXCEPTION_WITH_FILE_AND_LINE(SWIG_CSharpArgumentNullException, "jarg1 is null!");
     return 0;
   }
 
-  arg1 = (Dali::Actor *)jarg1;
+  arg1 = (Dali::Actor*)jarg1;
   {
-    try {
-      result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Actor::OnRelayoutSignalType*)&(arg1)->OnRelayoutSignal();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-
 // Signal Connect
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void* jarg1)
+{
+  bool                                                      jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)0;
+  bool                                                      result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
-  bool jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)jarg1;
   {
-    try {
-      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void* jarg1)
+{
+  unsigned long                                             jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)0;
+  std::size_t                                               result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)jarg1;
   {
-    try {
-      result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)0;
+  bool (*arg2)(Dali::Actor, Dali::TouchEvent const&)             = (bool (*)(Dali::Actor, Dali::TouchEvent const&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
-  bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
-  arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)jarg1;
+  arg2 = (bool (*)(Dali::Actor, Dali::TouchEvent const&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)0;
+  bool (*arg2)(Dali::Actor, Dali::TouchEvent const&)             = (bool (*)(Dali::Actor, Dali::TouchEvent const&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
-  bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
-  arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)jarg1;
+  arg2 = (bool (*)(Dali::Actor, Dali::TouchEvent const&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void* jarg1, void* jarg2, void* jarg3)
+{
+  bool                                                      jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)0;
+  Dali::Actor                                               arg2;
+  Dali::TouchEvent*                                         arg3 = 0;
+  Dali::Actor*                                              argp2;
+  bool                                                      result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
-  bool jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
-  Dali::Actor arg2 ;
-  Dali::TouchEvent *arg3 = 0 ;
-  Dali::Actor *argp2 ;
-  bool result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
-  argp2 = (Dali::Actor *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)jarg1;
+  argp2 = (Dali::Actor*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg2 = *argp2;
-  arg3 = (Dali::TouchEvent *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::TouchEvent*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1, arg2, (Dali::TouchEvent const&)*arg3);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
-  void * jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal()
+{
+  void*                                                     jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)new Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void* jarg1)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
-  Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::TouchEvent const&)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void* jarg1)
+{
+  bool                                                      jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)0;
+  bool                                                      result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
-  bool jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)jarg1;
   {
-    try {
-      result = (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 *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (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*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void* jarg1)
+{
+  unsigned long                                             jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)0;
+  std::size_t                                               result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)jarg1;
   {
-    try {
-      result = 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 *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = 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*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)0;
+  bool (*arg2)(Dali::Actor, Dali::HoverEvent const&)             = (bool (*)(Dali::Actor, Dali::HoverEvent const&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
-  bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
-  arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)jarg1;
+  arg2 = (bool (*)(Dali::Actor, Dali::HoverEvent const&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)0;
+  bool (*arg2)(Dali::Actor, Dali::HoverEvent const&)             = (bool (*)(Dali::Actor, Dali::HoverEvent const&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
-  bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
-  arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)jarg1;
+  arg2 = (bool (*)(Dali::Actor, Dali::HoverEvent const&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void* jarg1, void* jarg2, void* jarg3)
+{
+  bool                                                      jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)0;
+  Dali::Actor                                               arg2;
+  Dali::HoverEvent*                                         arg3 = 0;
+  Dali::Actor*                                              argp2;
+  bool                                                      result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
-  bool jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
-  Dali::Actor arg2 ;
-  Dali::HoverEvent *arg3 = 0 ;
-  Dali::Actor *argp2 ;
-  bool result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
-  argp2 = (Dali::Actor *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)jarg1;
+  argp2 = (Dali::Actor*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg2 = *argp2;
-  arg3 = (Dali::HoverEvent *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::HoverEvent*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1, arg2, (Dali::HoverEvent const&)*arg3);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
-  void * jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal()
+{
+  void*                                                     jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)new Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void* jarg1)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
-  Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::HoverEvent const&)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void* jarg1)
+{
+  bool                                                      jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)0;
+  bool                                                      result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
-  bool jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)jarg1;
   {
-    try {
-      result = (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 *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (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*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void* jarg1)
+{
+  unsigned long                                             jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)0;
+  std::size_t                                               result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)jarg1;
   {
-    try {
-      result = 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 *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = 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*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)0;
+  bool (*arg2)(Dali::Actor, Dali::WheelEvent const&)             = (bool (*)(Dali::Actor, Dali::WheelEvent const&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
-  bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
-  arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)jarg1;
+  arg2 = (bool (*)(Dali::Actor, Dali::WheelEvent const&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)0;
+  bool (*arg2)(Dali::Actor, Dali::WheelEvent const&)             = (bool (*)(Dali::Actor, Dali::WheelEvent const&))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
-  bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
-  arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)jarg1;
+  arg2 = (bool (*)(Dali::Actor, Dali::WheelEvent const&))jarg2;
   {
-    try {
-      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void* jarg1, void* jarg2, void* jarg3)
+{
+  bool                                                      jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)0;
+  Dali::Actor                                               arg2;
+  Dali::WheelEvent*                                         arg3 = 0;
+  Dali::Actor*                                              argp2;
+  bool                                                      result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
-  bool jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
-  Dali::Actor arg2 ;
-  Dali::WheelEvent *arg3 = 0 ;
-  Dali::Actor *argp2 ;
-  bool result;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
-  argp2 = (Dali::Actor *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)jarg1;
+  argp2 = (Dali::Actor*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
     return 0;
   }
   arg2 = *argp2;
-  arg3 = (Dali::WheelEvent *)jarg3;
-  if (!arg3) {
+  arg3 = (Dali::WheelEvent*)jarg3;
+  if(!arg3)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1, arg2, (Dali::WheelEvent const&)*arg3);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
-  void * jresult ;
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal()
+{
+  void*                                                     jresult;
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)new Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void* jarg1)
+{
+  Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>* arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
-  Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
-
-  arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
+  arg1 = (Dali::Signal<bool(Dali::Actor, Dali::WheelEvent const&)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void* jarg1)
+{
+  bool                             jresult;
+  Dali::Signal<void(Dali::Actor)>* arg1 = (Dali::Signal<void(Dali::Actor)>*)0;
+  bool                             result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
-  bool jresult ;
-  Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Actor)>*)jarg1;
   {
-    try {
-      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal<void(Dali::Actor)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void* jarg1)
+{
+  unsigned long                    jresult;
+  Dali::Signal<void(Dali::Actor)>* arg1 = (Dali::Signal<void(Dali::Actor)>*)0;
+  std::size_t                      result;
 
-SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
-  unsigned long jresult ;
-  Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
-  std::size_t result;
-
-  arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Actor)>*)jarg1;
   {
-    try {
-      result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal<void(Dali::Actor)> const*)arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (unsigned long)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Actor)>* arg1 = (Dali::Signal<void(Dali::Actor)>*)0;
+  void (*arg2)(Dali::Actor)             = (void (*)(Dali::Actor))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
-  void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Actor)>*)jarg1;
   arg2 = (void (*)(Dali::Actor))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Actor)>* arg1 = (Dali::Signal<void(Dali::Actor)>*)0;
+  void (*arg2)(Dali::Actor)             = (void (*)(Dali::Actor))0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
-  void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Actor)>*)jarg1;
   arg2 = (void (*)(Dali::Actor))jarg2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void* jarg1, void* jarg2)
+{
+  Dali::Signal<void(Dali::Actor)>* arg1 = (Dali::Signal<void(Dali::Actor)>*)0;
+  Dali::Actor                      arg2;
+  Dali::Actor*                     argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
-  Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
-  Dali::Actor arg2 ;
-  Dali::Actor *argp2 ;
-
-  arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
-  argp2 = (Dali::Actor *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Signal<void(Dali::Actor)>*)jarg1;
+  argp2 = (Dali::Actor*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
-      Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
-  void * jresult ;
-  Dali::Signal< void (Dali::Actor) > *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_ActorSignal()
+{
+  void*                            jresult;
+  Dali::Signal<void(Dali::Actor)>* result = 0;
 
   {
-    try {
-      result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Signal<void(Dali::Actor)>*)new Dali::Signal<void(Dali::Actor)>();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void* jarg1)
+{
+  Dali::Signal<void(Dali::Actor)>* arg1 = (Dali::Signal<void(Dali::Actor)>*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
-  Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
-
-  arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
+  arg1 = (Dali::Signal<void(Dali::Actor)>*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
 #ifdef __cplusplus
 }
 #endif

diff --git a/dali-csharp-binder/src/layer-wrap.cpp b/dali-csharp-binder/src/layer-wrap.cpp
index 2d0920b..ed7ad74 100644 (file)
--- a/dali-csharp-binder/src/layer-wrap.cpp
+++ b/dali-csharp-binder/src/layer-wrap.cpp
@@ -23,582 +23,630 @@
 
 extern SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback;
 
-
 using namespace Dali;
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
 // Property
 
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
+  result  = (int)Dali::Layer::Property::CLIPPING_ENABLE;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Layer::Property::CLIPPING_BOX;
+  result  = (int)Dali::Layer::Property::CLIPPING_BOX;
   jresult = (int)result;
   return jresult;
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
-  int jresult ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get()
+{
+  int jresult;
   int result;
 
-  result = (int)Dali::Layer::Property::BEHAVIOR;
+  result  = (int)Dali::Layer::Property::BEHAVIOR;
   jresult = (int)result;
   return jresult;
 }
 
-
 // Creation
 
-SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
-    return (Dali::Actor *)jarg1;
+SWIGEXPORT Dali::Actor* SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer* jarg1)
+{
+  return (Dali::Actor*)jarg1;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
-  void * jresult ;
-  Dali::Layer::Property *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer_Property()
+{
+  void*                  jresult;
+  Dali::Layer::Property* result = 0;
 
   {
-    try {
-      result = (Dali::Layer::Property *)new Dali::Layer::Property();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Layer::Property*)new Dali::Layer::Property();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void* jarg1)
+{
+  Dali::Layer::Property* arg1 = (Dali::Layer::Property*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
-  Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
-
-  arg1 = (Dali::Layer::Property *)jarg1;
+  arg1 = (Dali::Layer::Property*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
-  void * jresult ;
-  Dali::Layer *result = 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0()
+{
+  void*        jresult;
+  Dali::Layer* result = 0;
 
   {
-    try {
-      result = (Dali::Layer *)new Dali::Layer();
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Layer*)new Dali::Layer();
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
-  void * jresult ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_New()
+{
+  void*       jresult;
   Dali::Layer result;
 
   {
-    try {
+    try
+    {
       result = Dali::Layer::New();
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Layer((const Dali::Layer &)result);
+  jresult = new Dali::Layer((const Dali::Layer&)result);
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_DownCast(void* jarg1)
+{
+  void*             jresult;
+  Dali::BaseHandle  arg1;
+  Dali::BaseHandle* argp1;
+  Dali::Layer       result;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
-  void * jresult ;
-  Dali::BaseHandle arg1 ;
-  Dali::BaseHandle *argp1 ;
-  Dali::Layer result;
-
-  argp1 = (Dali::BaseHandle *)jarg1;
-  if (!argp1) {
+  argp1 = (Dali::BaseHandle*)jarg1;
+  if(!argp1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
     return 0;
   }
   arg1 = *argp1;
   {
-    try {
+    try
+    {
       result = Dali::Layer::DownCast(arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::Layer((const Dali::Layer &)result);
+  jresult = new Dali::Layer((const Dali::Layer&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void* jarg1)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
+    try
+    {
       delete arg1;
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void* jarg1)
+{
+  void*        jresult;
+  Dali::Layer* arg1   = 0;
+  Dali::Layer* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
-  void * jresult ;
-  Dali::Layer *arg1 = 0 ;
-  Dali::Layer *result = 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  if (!arg1) {
+  arg1 = (Dali::Layer*)jarg1;
+  if(!arg1)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Layer*)new Dali::Layer((Dali::Layer const&)*arg1);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_Assign(void* jarg1, void* jarg2)
+{
+  void*        jresult;
+  Dali::Layer* arg1   = (Dali::Layer*)0;
+  Dali::Layer* arg2   = 0;
+  Dali::Layer* result = 0;
 
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
-  void * jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer *arg2 = 0 ;
-  Dali::Layer *result = 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  arg2 = (Dali::Layer *)jarg2;
-  if (!arg2) {
+  arg1 = (Dali::Layer*)jarg1;
+  arg2 = (Dali::Layer*)jarg2;
+  if(!arg2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
     return 0;
   }
   {
-    try {
-      result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Layer*)&(arg1)->operator=((Dali::Layer const&)*arg2);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = (void *)result;
+  jresult = (void*)result;
   return jresult;
 }
 
-
 // Method
 
-SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
-  unsigned int jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void* jarg1)
+{
+  unsigned int jresult;
+  Dali::Layer* arg1 = (Dali::Layer*)0;
   unsigned int result;
 
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (unsigned int)((Dali::Layer const*)arg1)->GetProperty<int>(Layer::Property::DEPTH);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void* jarg1)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->Raise();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void* jarg1)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->Lower();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void* jarg1, void* jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  Dali::Layer  arg2;
+  Dali::Layer* argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer arg2 ;
-  Dali::Layer *argp2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  argp2 = (Dali::Layer *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Layer*)jarg1;
+  argp2 = (Dali::Layer*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
+    try
+    {
       (arg1)->RaiseAbove(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void* jarg1, void* jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  Dali::Layer  arg2;
+  Dali::Layer* argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer arg2 ;
-  Dali::Layer *argp2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  argp2 = (Dali::Layer *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Layer*)jarg1;
+  argp2 = (Dali::Layer*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
+    try
+    {
       (arg1)->LowerBelow(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void* jarg1)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->RaiseToTop();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void* jarg1)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
+    try
+    {
       (arg1)->LowerToBottom();
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void* jarg1, void* jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  Dali::Layer  arg2;
+  Dali::Layer* argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer arg2 ;
-  Dali::Layer *argp2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  argp2 = (Dali::Layer *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Layer*)jarg1;
+  argp2 = (Dali::Layer*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
+    try
+    {
       (arg1)->MoveAbove(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void* jarg1, void* jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  Dali::Layer  arg2;
+  Dali::Layer* argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer arg2 ;
-  Dali::Layer *argp2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  argp2 = (Dali::Layer *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Layer*)jarg1;
+  argp2 = (Dali::Layer*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
+    try
+    {
       (arg1)->MoveBelow(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void* jarg1, int jarg2)
+{
+  Dali::Layer*          arg1 = (Dali::Layer*)0;
+  Dali::Layer::Behavior arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer::Behavior arg2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = (Dali::Layer::Behavior)jarg2;
   {
-    try {
-      (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Layer::Property::BEHAVIOR, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
-  int jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void* jarg1)
+{
+  int                   jresult;
+  Dali::Layer*          arg1 = (Dali::Layer*)0;
   Dali::Layer::Behavior result;
 
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (Dali::Layer::Behavior)((Dali::Layer const*)arg1)->GetProperty<Dali::Layer::Behavior>(Dali::Layer::Property::BEHAVIOR);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = (int)result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void* jarg1, bool jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, bool jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool arg2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_ENABLE, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void* jarg1)
+{
+  bool         jresult;
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
-  bool jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Dali::Layer::Property::CLIPPING_ENABLE);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void* jarg1, int jarg2, int jarg3, int jarg4, int jarg5)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  int          arg2;
+  int          arg3;
+  int          arg4;
+  int          arg5;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  int arg2 ;
-  int arg3 ;
-  int arg4 ;
-  int arg5 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = (int)jarg2;
   arg3 = (int)jarg3;
   arg4 = (int)jarg4;
   arg5 = (int)jarg5;
   {
-    try {
-      (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>(arg2, arg3, arg4, arg5));
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void* jarg1, void* jarg2)
+{
+  Dali::Layer*       arg1 = (Dali::Layer*)0;
+  Dali::ClippingBox  arg2;
+  Dali::ClippingBox* argp2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::ClippingBox arg2 ;
-  Dali::ClippingBox *argp2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
-  argp2 = (Dali::ClippingBox *)jarg2;
-  if (!argp2) {
+  arg1  = (Dali::Layer*)jarg1;
+  argp2 = (Dali::ClippingBox*)jarg2;
+  if(!argp2)
+  {
     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
-    return ;
+    return;
   }
   arg2 = *argp2;
   {
-    try {
-      (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Dali::Layer::Property::CLIPPING_BOX, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
-
-SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
-  void * jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
+SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void* jarg1)
+{
+  void*             jresult;
+  Dali::Layer*      arg1 = (Dali::Layer*)0;
   Dali::ClippingBox result;
 
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = ((Dali::Layer const*)arg1)->GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
-  jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
+  jresult = new Dali::ClippingBox((const Dali::ClippingBox&)result);
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void* jarg1, bool jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, bool jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool arg2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Layer::Property::DEPTH_TEST, !arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void* jarg1)
+{
+  bool         jresult;
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
-  bool jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = !(bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Layer::Property::DEPTH_TEST);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void* jarg1, void* jarg2)
+{
+  Dali::Layer*                  arg1 = (Dali::Layer*)0;
+  Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType)0;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = (Dali::Layer::SortFunctionType)jarg2;
   {
-    try {
+    try
+    {
       (arg1)->SetSortFunction(arg2);
-    } CALL_CATCH_EXCEPTION();
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void* jarg1, bool jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, bool jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool arg2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Layer::Property::CONSUMES_TOUCH, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void* jarg1)
+{
+  bool         jresult;
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
-  bool jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Layer::Property::CONSUMES_TOUCH);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void* jarg1, bool jarg2)
+{
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         arg2;
 
-SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, bool jarg2) {
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool arg2 ;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   arg2 = jarg2 ? true : false;
   {
-    try {
-      (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
-    } CALL_CATCH_EXCEPTION();
+    try
+    {
+      (arg1)->SetProperty(Layer::Property::CONSUMES_HOVER, arg2);
+    }
+    CALL_CATCH_EXCEPTION();
   }
-
 }
 
+SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void* jarg1)
+{
+  bool         jresult;
+  Dali::Layer* arg1 = (Dali::Layer*)0;
+  bool         result;
 
-SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
-  bool jresult ;
-  Dali::Layer *arg1 = (Dali::Layer *) 0 ;
-  bool result;
-
-  arg1 = (Dali::Layer *)jarg1;
+  arg1 = (Dali::Layer*)jarg1;
   {
-    try {
-      result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
-    } CALL_CATCH_EXCEPTION(0);
+    try
+    {
+      result = (bool)((Dali::Layer const*)arg1)->GetProperty<bool>(Layer::Property::CONSUMES_HOVER);
+    }
+    CALL_CATCH_EXCEPTION(0);
   }
 
   jresult = result;
   return jresult;
 }
 
-
-
 #ifdef __cplusplus
 }
 #endif