Merge "Add SetProperty and GetProperty to Visuals." into devel/master
authorAdeel Kazmi <adeel.kazmi@samsung.com>
Thu, 13 Oct 2016 09:35:10 +0000 (02:35 -0700)
committerGerrit Code Review <gerrit@review.vlan103.tizen.org>
Thu, 13 Oct 2016 09:35:10 +0000 (02:35 -0700)
293 files changed:
automated-tests/src/dali-toolkit/CMakeLists.txt
automated-tests/src/dali-toolkit/utc-Dali-NavigationView.cpp [new file with mode: 0644]
build/tizen/Makefile.am [changed mode: 0644->0755]
build/tizen/configure.ac [changed mode: 0644->0755]
build/tizen/dali-toolkit/Makefile.am
build/tizen/plugins/csharp/Makefile.am [new file with mode: 0755]
build/tizen/plugins/javascript/Makefile.am [moved from build/tizen/plugins/Makefile.am with 87% similarity]
dali-csharp-wrapper.manifest [new file with mode: 0755]
dali-toolkit/devel-api/controls/navigation-view/navigation-view.cpp [new file with mode: 0644]
dali-toolkit/devel-api/controls/navigation-view/navigation-view.h [new file with mode: 0644]
dali-toolkit/devel-api/file.list
dali-toolkit/internal/controls/navigation-view/navigation-view-impl.cpp [new file with mode: 0644]
dali-toolkit/internal/controls/navigation-view/navigation-view-impl.h [new file with mode: 0644]
dali-toolkit/internal/file.list
packaging/dali-csharp-wrapper.spec [new file with mode: 0755]
plugins/dali-swig/NDali.dll [new file with mode: 0755]
plugins/dali-swig/SWIG/dali-adaptor.i [changed mode: 0644->0755]
plugins/dali-swig/SWIG/dali.i [changed mode: 0644->0755]
plugins/dali-swig/SWIG/events/accessibilitymanager-event.i
plugins/dali-swig/SWIG/events/actor-event.i
plugins/dali-swig/SWIG/events/button-event.i
plugins/dali-swig/SWIG/events/control-event.i
plugins/dali-swig/SWIG/events/slider-event.i
plugins/dali-swig/SWIG/events/timer-event.i
plugins/dali-swig/automatic/cpp/dali_wrap.cpp [new file with mode: 0644]
plugins/dali-swig/automatic/cpp/dali_wrap.h [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AccessibilityActionScrollSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AccessibilityActionSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AccessibilityFocusOvershotSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AccessibilityManager.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Actor.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ActorContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ActorHoverEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ActorSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ActorTouchDataSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ActorTouchEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ActorWheelEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Alignment.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AlphaFunction.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AngleAxis.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AngleThresholdPair.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Animation.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/AnimationSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Any.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Application.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ApplicationControlSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ApplicationSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BaseHandle.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BaseObject.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BlendEquationType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BlendFactorType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BlendModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BoolSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/BufferImage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Builder.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Button.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ButtonSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/CameraActor.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/CameraType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/CheckBoxButton.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ClampState.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ClampState2D.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ClippingModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ColorMode.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ConnectionTracker.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ConnectionTrackerInterface.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ControlKeyEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ControlOrientationType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/CustomActor.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/CustomActorImpl.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DefaultItemLayoutType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DefaultRuler.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Degree.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DepthFunctionType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DepthTestModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DepthWriteModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DimensionType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DirectionBias.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DragAndDropDetector.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/DrawModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/EncodedBufferImage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FaceCullingModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FilterModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FittingModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FixedRuler.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FlexContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FloatSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FocusChangedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FocusGroupChangedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FrameBuffer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/FrameBufferImage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/GaussianBlurView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/GaussianBlurViewSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Geometry.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Gesture.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/GestureDetector.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/GradientVisualSpreadMethodType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/GradientVisualUnitsType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Handle.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/HorizontalAlignmentType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/HoverEvent.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Image.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ImageSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ImageView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Item.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ItemContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ItemFactory.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ItemIdContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ItemLayout.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ItemRange.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ItemView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/KeyEvent.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/KeyEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/KeyFrames.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/KeyInputFocusSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Layer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/LinearConstrainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/LoadingState.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/LongPressGesture.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/LongPressGestureDetectedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/LongPressGestureDetector.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Matrix.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Matrix3.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/MeshVisualShadingModeValue.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Meta.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Model3dView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/NDalic.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/NDalicPINVOKE.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/NativeImage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/NativeImageInterface.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/NinePatchImage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ObjectCreatedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ObjectDestroyedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ObjectRegistry.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PageFactory.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PagePanSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PageTurnLandscapeView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PageTurnPortraitView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PageTurnSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PageTurnView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PanGesture.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PanGestureDetectedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PanGestureDetector.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Path.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PathConstrainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PinchGesture.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PinchGestureDetectedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PinchGestureDetector.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PixelData.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PixelFormat.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PointStateType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Popup.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PositionInheritanceMode.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PrimitiveVisualShapeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ProgressBar.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ProjectionMode.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Property.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PropertyBuffer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PropertyCondition.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PropertyNotification.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PropertyNotifySignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PropertyRanges.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/PushButton.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Quaternion.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Radian.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RadioButton.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RectDouble.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RectFloat.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RectInteger.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RectUnsignedInteger.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RefObject.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RelayoutContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RenderBufferFormat.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RenderModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RenderTask.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RenderTaskList.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RenderTaskSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Renderer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RenderingType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ResizePolicyType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ResourceImage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ResourceImageSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Ruler.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RulerDomain.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/RulerPtr.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_CallbackBase.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Configuration__ContextLoss.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__CallbackBase.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__Constraint.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__FunctorDelegate.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__IntrusivePtrT_Dali__Toolkit__ItemLayout_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__SignalT_void_fDali__DragAndDropDetectorF_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__ProgressBar_floatF_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextEditor_Dali__Toolkit__TextEditor__InputStyle__MaskF_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__SignalT_void_fDali__Toolkit__TextField_Dali__Toolkit__TextField__InputStyle__MaskF_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__SignalT_void_fboolF_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__Toolkit__ClampState.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_Dali__Toolkit__Internal__Visual__Base.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_FunctorDelegate.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_PropertyInputContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_double.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f___Dali__BaseHandle.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f___bool.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f_float__float.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f_p_q_const__Dali__Any__AnyContainerBase__void.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f_r_Dali__Vector2__bool.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f_r_q_const__Dali__Any__AnyContainerBase__p_Dali__Any__AnyContainerBase.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_f_r_q_const__Dali__Vector3__float.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_float.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_int.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_std__type_info.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_uint8_t.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_unsigned_char.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_unsigned_int.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SWIGTYPE_p_unsigned_short.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Sampler.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SamplingModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ScrollBar.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ScrollView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ScrollViewEffect.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ScrollViewPagePathEffect.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ScrollViewSnapStartedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Scrollable.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ScrollableSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Shader.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SignalObserver.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SizeScalePolicyType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Slider.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SliderMarkReachedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SliderValueChangedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SlotObserver.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/SnapType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Stage.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StageWheelEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StencilFunctionType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StencilOperationType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StringValuePair.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StyleChangeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StyleChangedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/StyleManager.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TableView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TapGesture.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TapGestureDetectedSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TapGestureDetector.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextEditor.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextEditorSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextField.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextFieldSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextLabel.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Texture.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextureSet.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TextureType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TimePeriod.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Timer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TimerSignalType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ToolkitPropertyRange.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TouchData.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TouchEvent.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TouchEventSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TouchPoint.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TouchPointContainer.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TouchSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/TypeInfo.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Uint16Pair.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Vector2.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Vector3.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Vector4.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VectorBase.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VectorFloat.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VectorInteger.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VectorUint16Pair.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VectorUnsignedChar.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VerticalAlignmentType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VideoView.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VideoViewSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/View.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ViewImpl.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ViewMode.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VisualBase.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VisualFactory.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VisualType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/VoidSignal.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/WheelEvent.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/Window.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/WrapModeType.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/doublep.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/floatp.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/intp.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/uintp.cs [new file with mode: 0644]
plugins/dali-swig/automatic/csharp/ushortp.cs [new file with mode: 0644]
plugins/dali-swig/examples/hello-test.cs [new file with mode: 0755]
plugins/dali-swig/manual/csharp/DaliEventHandler.cs
plugins/dali-swig/manual/csharp/Tizen.Applications/DaliApplication.cs [new file with mode: 0755]

index d6ad543..6031392 100644 (file)
@@ -41,6 +41,7 @@ SET(TC_SOURCES
    utc-Dali-ItemView.cpp
    utc-Dali-KeyboardFocusManager.cpp
    utc-Dali-Magnifier.cpp
+   utc-Dali-NavigationView.cpp
    utc-Dali-Popup.cpp
    utc-Dali-ProgressBar.cpp
    utc-Dali-PushButton.cpp
diff --git a/automated-tests/src/dali-toolkit/utc-Dali-NavigationView.cpp b/automated-tests/src/dali-toolkit/utc-Dali-NavigationView.cpp
new file mode 100644 (file)
index 0000000..e91b2cc
--- /dev/null
@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <sstream>
+#include <dali-toolkit-test-suite-utils.h>
+#include <dali-toolkit/dali-toolkit.h>
+#include <dali-toolkit/devel-api/controls/navigation-view/navigation-view.h>
+
+using namespace Dali;
+using namespace Toolkit;
+
+void dali_navigationView_startup(void)
+{
+  test_return_value = TET_UNDEF;
+}
+
+void dali_navigationView_cleanup(void)
+{
+  test_return_value = TET_PASS;
+}
+
+int UtcDaliNavigationTypeRegistry(void)
+{
+  ToolkitTestApplication application;
+
+  TypeRegistry typeRegistry = TypeRegistry::Get();
+  DALI_TEST_CHECK( typeRegistry );
+
+  TypeInfo typeInfo = typeRegistry.GetTypeInfo( "NavigationView" );
+  DALI_TEST_CHECK( typeInfo );
+
+  BaseHandle handle = typeInfo.CreateInstance();
+  DALI_TEST_CHECK( handle );
+
+  NavigationView view = NavigationView::DownCast( handle );
+  DALI_TEST_CHECK( view );
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewNew(void)
+{
+  ToolkitTestApplication application;
+
+  NavigationView navigationView;
+  DALI_TEST_CHECK( !navigationView );
+
+  navigationView = NavigationView::New();
+  DALI_TEST_CHECK( navigationView );
+
+  Stage::GetCurrent().Add( navigationView );
+
+  application.SendNotification();
+  application.Render();
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewCopyAndAssignment(void)
+{
+  ToolkitTestApplication application;
+
+  NavigationView view = NavigationView::New();
+  DALI_TEST_CHECK( view );
+
+  NavigationView copy( view );
+  DALI_TEST_CHECK( copy == view );
+
+  NavigationView assign;
+  DALI_TEST_CHECK( !assign );
+  assign = view;
+  DALI_TEST_CHECK( assign == view );
+
+  // Self assignment
+  assign = assign;
+  DALI_TEST_CHECK( assign );
+  DALI_TEST_CHECK( assign == view );
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewDownCast(void)
+{
+  ToolkitTestApplication application;
+
+  BaseHandle view = NavigationView::New();
+  DALI_TEST_CHECK( NavigationView::DownCast( view ) );
+
+  BaseHandle empty;
+  DALI_TEST_CHECK( ! NavigationView::DownCast( empty ) );
+
+  BaseHandle another = Actor::New();
+  DALI_TEST_CHECK( ! NavigationView::DownCast( another ) );
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewPush(void)
+{
+  ToolkitTestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+
+  // 1 Create and Add Navigation View to stage, actor count should be zero
+  NavigationView naviView = NavigationView::New();
+  stage.Add( naviView );
+
+  DALI_TEST_EQUALS( naviView.GetChildCount(), 0,  TEST_LOCATION );
+
+  // 2 Add Actor to Navigation View, actor count should increase to 1
+
+  Actor TestParentActor1 = Actor::New();
+  naviView.Push( TestParentActor1 );
+
+  DALI_TEST_EQUALS( naviView.GetChildCount(), 1,  TEST_LOCATION );
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewPop(void)
+{
+  ToolkitTestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+
+  // 1 Create Navigation View
+  NavigationView naviView = NavigationView::New();
+  stage.Add( naviView );
+
+  // 2 Push initial Actor
+  Actor testParentActor1 = Actor::New();
+  testParentActor1.SetName("TestParentActor1");
+  naviView.Push( testParentActor1 );
+  DALI_TEST_EQUALS( naviView.GetChildCount(), 1 ,  TEST_LOCATION );
+
+  // 3 Push Second Actor which contains a child actor
+  Actor testParentActor2 = Actor::New();
+  testParentActor2.SetName("TestParentActor2");
+  Actor testChildActor1 = Actor::New();
+  testParentActor2.Add( testChildActor1 );
+  naviView.Push( testParentActor2 );
+
+
+  // 4 Pop head actor, it should be TestParentActor2
+  Actor poppedActor = naviView.Pop();
+  DALI_TEST_EQUALS( poppedActor.GetName() ,  "TestParentActor2", TEST_LOCATION );
+
+  // 5 Navigation View child count should be 1
+  DALI_TEST_EQUALS( naviView.GetChildCount(), 1 ,  TEST_LOCATION );
+
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewPushAndPop(void)
+{
+  ToolkitTestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+
+  // 1 Create Navigation View
+  NavigationView naviView = NavigationView::New();
+  stage.Add( naviView );
+
+  // 2 Push initial Actor
+  Actor testParentActor1 = Actor::New();
+  testParentActor1.SetName("TestParentActor1");
+  naviView.Push( testParentActor1 );
+  DALI_TEST_EQUALS( naviView.GetChildCount(), 1 ,  TEST_LOCATION );
+
+  // 3 Push Second Actor which contains a child actor
+  Actor testParentActor2 = Actor::New();
+  testParentActor2.SetName("TestParentActor2");
+  Actor testChildActor1 = Actor::New();
+  testParentActor2.Add( testChildActor1 );
+  naviView.Push( testParentActor2 );
+
+  // 3 Push third Actor which contains a child actor
+  Actor testParentActor3 = Actor::New();
+  testParentActor3.SetName("TestParentActor3");
+  Actor testChildActor2 = Actor::New();
+  testParentActor2.Add( testChildActor2 );
+  naviView.Push( testParentActor3 );
+
+  // 4 Pop head actor,  it should be TestParentActor3
+  Actor poppedActor = naviView.Pop();
+  DALI_TEST_EQUALS( poppedActor.GetName() ,  "TestParentActor3", TEST_LOCATION );
+
+  // 5 Pop head actor,  it should be TestParentActor2
+  Actor poppedActor2 = naviView.Pop();
+  DALI_TEST_EQUALS( poppedActor2.GetName() ,  "TestParentActor2", TEST_LOCATION );
+
+
+  END_TEST;
+}
+
+int UtcDaliNavigationViewPreventLastPop(void)
+{
+  ToolkitTestApplication application;
+
+  Stage stage = Stage::GetCurrent();
+
+  // 1 Create Navigation View
+  NavigationView naviView = NavigationView::New();
+  stage.Add( naviView );
+
+  // 2 Push initial Actor
+  Actor testParentActor1 = Actor::New();
+  testParentActor1.SetName("TestParentActor1");
+  naviView.Push( testParentActor1 );
+  DALI_TEST_EQUALS( naviView.GetChildCount(), 1 ,  TEST_LOCATION );
+
+  // 3 Push Second Actor which contains a child actor
+  Actor testParentActor2 = Actor::New();
+  testParentActor2.SetName("TestParentActor2");
+  Actor testChildActor1 = Actor::New();
+  testParentActor2.Add( testChildActor1 );
+  naviView.Push( testParentActor2 );
+
+  // 4 Pop head actor, it should be TestParentActor2
+  Actor poppedActor1 = naviView.Pop();
+  DALI_TEST_EQUALS( poppedActor1.GetName() ,  "TestParentActor2", TEST_LOCATION );
+
+
+  // 5 Try to Pop head actor, Should be empty hence can not get name of Actor
+  Actor poppedActorEmpty = naviView.Pop();
+
+  try
+  {
+    const std::string hasNoName = poppedActorEmpty.GetName();
+    tet_infoline( hasNoName.c_str() );
+    DALI_TEST_CHECK( false ); // should not get here
+  }
+  catch( ... )
+  {
+    DALI_TEST_CHECK( true );
+  }
+
+
+  END_TEST;
+}
old mode 100644 (file)
new mode 100755 (executable)
index 0d0e733..89a5e28
 SUBDIRS = dali-toolkit
 
 if ENABLE_JAVASCRIPT_PLUGIN
-SUBDIRS +=plugins
+SUBDIRS +=plugins/javascript
+endif
+
+if ENABLE_CSHARP_PLUGIN
+SUBDIRS +=plugins/csharp
 endif
 
 # perform documentation last, so it doesn't prevent code from building if there's an error
old mode 100644 (file)
new mode 100755 (executable)
index 21e03da..f12ab89
@@ -59,10 +59,21 @@ AC_ARG_ENABLE([i18n],
 #  no setting                // enable_javascript = automatic ( enable if v8 present)
 AC_ARG_ENABLE([javascript],
               [AC_HELP_STRING([--enable-javascript],
-               [Enable JavaScript plugin])] ,
-               [enable_javascript=$enableval],
-               [enable_javascript=automatic])
+                [Enable JavaScript plugin])],
+              [enable_javascript=$enableval],
+              [enable_javascript=automatic])
 
+# option to build C# plugin
+# configure settings and output
+# --enable-csharp        // enable_csharp = yes
+# --enable-csharp=yes    // enable_csharp = yes
+# --enable-csharp=no     // enable_csharp = no
+#  no setting            // enable_csharp = no
+AC_ARG_ENABLE([csharp],
+              [AC_HELP_STRING([--enable-csharp],
+                [Enable csharp plugin])],
+              [enable_csharp=$enableval],
+              [enable_csharp=automatic])
 
 if test "x$enable_debug" = "xyes"; then
   DALI_TOOLKIT_CFLAGS="$DALI_TOOLKIT_CFLAGS -DDEBUG_ENABLED"
@@ -162,10 +173,45 @@ DOXYGEN_ROOT_DIR=../../..
 AC_SUBST(DOXYGEN_DOCS_DIR)
 AC_SUBST(DOXYGEN_ROOT_DIR)
 
+# Enable csharp plugin
+build_csharp_plugin=no
+build_ruby_flag=no
+if test x$enable_csharp = xyes; then
+  [build_csharp_plugin=yes]
+  AC_MSG_NOTICE(Building DALi csharp plugin ...)
+
+  PKG_CHECK_MODULES(DALIADAPTOR, dali-adaptor)
+  AC_PATH_PROG([SWIG], [swig])
+
+  # if gbs enable, then only use swig, without ruby or mcs
+  if test "x$dali_profile" = "xUBUNTU"; then
+    [build_ruby_flag=yes]
+    AC_PATH_PROG([RUBY], [ruby])
+    AC_PATH_PROGS([MCS], [mcs gmcs gmcs2])
+    AC_MSG_NOTICE(swig ruby mcs working ...)
+  else
+    [build_ruby_flag=no]
+    AC_PATH_PROG([RUBY], [ruby])
+    #AC_PATH_PROGS([MCS], [mcs gmcs gmcs2])
+    #AC_MSG_NOTICE(swig only working ...)
+  fi
+
+  # Set varaibles for dali-toolkit
+  DALITOOLKIT_CFLAGS="-I${prefix}/include -I${prefix}/include/dali-toolkit"
+  DALITOOLKIT_LIBS="-L${prefix}/lib -ldali-toolkit -ldali-core"
+  AC_SUBST(DALITOOLKIT_CFLAGS)
+  AC_SUBST(DALITOOLKIT_LIBS)
+fi
+
+#set a variable for the makefile to force compile the csharp plugin
+AM_CONDITIONAL([ENABLE_CSHARP_PLUGIN], [test x$build_csharp_plugin = xyes])
+AM_CONDITIONAL([ENABLE_RUBY_FLAG], [test x$build_ruby_flag = xyes])
+
 AC_CONFIG_FILES([
  Makefile
  dali-toolkit/Makefile
- plugins/Makefile
+ plugins/javascript/Makefile
+ plugins/csharp/Makefile
  dali-toolkit.pc
  docs/Makefile
  docs/dali.doxy
@@ -181,6 +227,7 @@ Configuration
   Prefix:                           $prefix
   Debug Build:                      $enable_debug
   JavaScript support (V8 required)  $build_javascript_plugin
+  CSharp support                    $build_csharp_plugin
   Profile:                          $dali_profile
   Data Dir (Read/Write):            $dataReadWriteDir
   Data Dir (Read Only):             $dataReadOnlyDir
index cfb5d18..fd09527 100644 (file)
@@ -104,6 +104,7 @@ develapibubbleemitterdir =      $(develapicontrolsdir)/bubble-effect
 develapieffectsviewdir =        $(develapicontrolsdir)/effects-view
 develapigaussianblurviewdir =   $(develapicontrolsdir)/gaussian-blur-view
 develapimagnifierdir =          $(develapicontrolsdir)/magnifier
+develapinavigationviewdir =     $(develapicontrolsdir)/navigation-view
 develapipageturnviewdir =       $(develapicontrolsdir)/page-turn-view
 develapipopupdir =              $(develapicontrolsdir)/popup
 develapiprogressbardir =        $(develapicontrolsdir)/progress-bar
@@ -129,6 +130,7 @@ develapifocusmanager_HEADERS =      $(devel_api_focus_manager_header_files)
 develapigaussianblurview_HEADERS =  $(devel_api_gaussian_blur_view_header_files)
 develapiimageloader_HEADERS =       $(devel_api_image_loader_header_files)
 develapimagnifier_HEADERS =         $(devel_api_magnifier_header_files)
+develapinavigationview_HEADERS =    $(devel_api_navigation_view_header_files)
 develapipageturnview_HEADERS =      $(devel_api_page_turn_view_header_files)
 develapipopup_HEADERS =             $(devel_api_popup_header_files)
 develapiprogressbar_HEADERS =       $(devel_api_progress_bar_header_files)
diff --git a/build/tizen/plugins/csharp/Makefile.am b/build/tizen/plugins/csharp/Makefile.am
new file mode 100755 (executable)
index 0000000..26a88ec
--- /dev/null
@@ -0,0 +1,51 @@
+# Copyright (c) 2016 Samsung Electronics Co., Ltd.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+# http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+dali_swig_dir = ../../../../plugins/dali-swig
+
+BUILT_SOURCES = \
+          $(dali_swig_dir)/automatic/cpp/dali_wrap.cpp \
+          $(dali_swig_dir)/automatic/cpp/dali_wrap.h \
+          $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.cpp
+
+all-local: 
+gbs-local: libNDalic.so NDali.dll
+
+libNDalic.so: $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o
+       $(CXX) -shared $(dali_swig_dir)/automatic/cpp/dali_wrap.o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o -o $(dali_swig_dir)/libNDalic.so $(DALICORE_LIBS) $(DALIADAPTOR_LIBS) $(DALITOOLKIT_LIBS)
+
+$(dali_swig_dir)/automatic/cpp/dali_wrap.o: $(BUILT_SOURCES)
+       $(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/automatic/cpp/dali_wrap.cpp -o $(dali_swig_dir)/automatic/cpp/dali_wrap.o
+
+$(dali_swig_dir)/manual/cpp/dali_wrap_manual.o: $(BUILT_SOURCES)
+       $(CXX) -c -fpic $(CXXFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) $(dali_swig_dir)/manual/cpp/keyboard_focus_manager_wrap.cpp -o $(dali_swig_dir)/manual/cpp/dali_wrap_manual.o
+
+NDali.dll: $(BUILT_SOURCES)
+#      mcs -nologo -target:library -out:$(dali_swig_dir)/NDali.dll $(dali_swig_dir)/automatic/csharp/*.cs $(dali_swig_dir)/manual/csharp/*.cs
+
+$(BUILT_SOURCES): $(dali_swig_dir)/SWIG/*.i
+       rm -f $(dali_swig_dir)/automatic/csharp/*.cs
+       rm -f $(dali_swig_dir)/automatic/cpp/*.cpp
+       $(SWIG) -version
+       $(SWIG) -csharp -c++ -outdir $(dali_swig_dir)/automatic/csharp \
+            $(DALI_CFLAGS) $(DALICORE_CFLAGS) $(DALIADAPTOR_CFLAGS) $(DALITOOLKIT_CFLAGS) -namespace Dali -o $(dali_swig_dir)/automatic/cpp/dali_wrap.cpp $(dali_swig_dir)/SWIG/dali.i
+
+gbs-install: gbs-local
+       -$(INSTALL) -d $(DESTDIR)
+       -$(INSTALL) $(dali_swig_dir)/libNDalic.so $(DESTDIR)
+       -$(INSTALL) $(dali_swig_dir)/NDali.dll $(DESTDIR)
+
+EXTRA_DIST = \
+    swig.cmd
+
similarity index 87%
rename from build/tizen/plugins/Makefile.am
rename to build/tizen/plugins/javascript/Makefile.am
index 9d0b25b..0bb1082 100644 (file)
@@ -16,9 +16,9 @@
 
 # Build the Dali Toolkit library
 
-plugin_src_dir = ../../../plugins
+plugin_src_dir = ../../../../plugins
 
-include ../../../plugins/dali-script-v8/file.list
+include ../../../../plugins/dali-script-v8/file.list
 
 
 lib_LTLIBRARIES = libdali-script-plugin-v8.la
@@ -29,8 +29,8 @@ lib_LTLIBRARIES = libdali-script-plugin-v8.la
 # install path for dali-toolkit.h, is dali-toolkit.h is not installed yet.
 # It won't be installed until the rpm is installed, and unfortunately the
 # plugin is part of the same rpm
-script_plugin_v8_includes = -I../../../plugins/dali-script-v8/src \
-                            -I../../../plugins/dali-script-v8/src/utils
+script_plugin_v8_includes = -I../../../../plugins/dali-script-v8/src \
+                            -I../../../../plugins/dali-script-v8/src/utils
 
 
 libdali_script_plugin_v8_la_SOURCES = \
@@ -39,7 +39,7 @@ libdali_script_plugin_v8_la_SOURCES = \
 libdali_script_plugin_v8_la_DEPENDENCIES =
 
 libdali_script_plugin_v8_la_CXXFLAGS = -DDALI_COMPILATION \
-                            -I../../../ \
+                            -I../../../../ \
                             $(V8_CFLAGS) \
                             $(DALI_TOOLKIT_CFLAGS) \
                             $(DALICORE_CFLAGS) \
diff --git a/dali-csharp-wrapper.manifest b/dali-csharp-wrapper.manifest
new file mode 100755 (executable)
index 0000000..75b0fa5
--- /dev/null
@@ -0,0 +1,5 @@
+<manifest>
+    <request>
+        <domain name="_"/>
+    </request>
+</manifest>
diff --git a/dali-toolkit/devel-api/controls/navigation-view/navigation-view.cpp b/dali-toolkit/devel-api/controls/navigation-view/navigation-view.cpp
new file mode 100644 (file)
index 0000000..cffecf9
--- /dev/null
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/devel-api/controls/navigation-view/navigation-view.h>
+
+// EXTERNAL INCLUDES
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/navigation-view/navigation-view-impl.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+NavigationView::NavigationView()
+{
+}
+
+NavigationView::NavigationView( const NavigationView& handle )
+: Control(handle)
+{
+}
+
+NavigationView& NavigationView::operator=( const NavigationView& handle)
+{
+  if( &handle != this )
+  {
+    Control::operator=( handle );
+  }
+  return *this;
+}
+
+NavigationView::~NavigationView()
+{
+}
+
+NavigationView NavigationView::New()
+{
+  return Internal::NavigationView::New();
+}
+
+NavigationView NavigationView::DownCast( BaseHandle handle )
+{
+  return Control::DownCast<NavigationView, Internal::NavigationView>(handle);
+}
+
+NavigationView::NavigationView( Internal::NavigationView& implementation )
+: Control( implementation )
+{
+}
+
+NavigationView::NavigationView( Dali::Internal::CustomActor* internal )
+: Control( internal)
+{
+  VerifyCustomActorPointer<Internal::NavigationView>(internal);
+}
+
+
+void NavigationView::Push( Actor actor )
+{
+  GetImpl( *this ).Push( actor );
+}
+
+Actor NavigationView::Pop()
+{
+  return GetImpl( *this ).Pop();
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
diff --git a/dali-toolkit/devel-api/controls/navigation-view/navigation-view.h b/dali-toolkit/devel-api/controls/navigation-view/navigation-view.h
new file mode 100644 (file)
index 0000000..1ff0f65
--- /dev/null
@@ -0,0 +1,132 @@
+#ifndef DALI_TOOLKIT_NAVIGATION_VIEW_H
+#define DALI_TOOLKIT_NAVIGATION_VIEW_H
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/animation/alpha-function.h>
+#include <dali-toolkit/public-api/controls/control.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal DALI_INTERNAL
+{
+// Forward declarations
+class NavigationView;
+}
+
+/**
+ * @brief NavigationView implements a view that manages the navigation of hierarchical contents.
+ *
+ * An Actor is pushed onto the NavigationView, itself and its children are added to the stage.
+ * The actors currently shown are replaced.
+ * When pop is called on the NavigationView, the current tree of Actors are removed and the previous set added back.
+ * If pop is called on the last set of Actors then they remain, nothing is popped.
+ */
+class DALI_IMPORT_API NavigationView : public Control
+{
+
+public:
+
+  /**
+   * @brief Create a NavigationView handle; this can be initialize with NavigationView::New().
+   *
+   * @note Calling member function with an uninitialized handle is not allowed.
+   */
+  NavigationView();
+
+  /**
+   * @brief Copy Constructor.
+   * @param[in] handle Handle to copy.
+   */
+  NavigationView( const NavigationView& handle );
+
+ /**
+  * @brief Assignment operator.
+  * @param handle The handle to copy from.
+  * @return reference to this
+  */
+  NavigationView& operator=( const NavigationView& handle );
+
+  /**
+   * @brief Destructor
+   *
+   * This is non-virtual since derived Handle types must not contain data or virtual methods.
+   */
+  ~NavigationView();
+
+  /**
+   * @brief  Create an initialized NavigationView.
+   *
+   * @return A handle to a newly allocated Dali resource.
+   */
+  static NavigationView New();
+
+  /**
+   * @brief Downcast an object handle to NavigationView.
+   *
+   * @details If handle points to a NavigationView, the downcast produces a valid handle.
+   * If not, the returned handle is left uninitialized.
+   * @param[in] handle Handle to an object.
+   * @return handle to a NavigationView of an uninitialized handle.
+   */
+  static NavigationView DownCast( BaseHandle handle );
+
+  /**
+   * @brief Push a new actor tree to the top of the NavigationView stack and show it.
+   * @param[in] item An actor tree.
+   */
+  void Push( Actor item );
+
+  /**
+   * @brief Pop the actor tree that is on the top of the NavigationView stack and make it disappear.
+   *
+   * @return The Actor tree popped out.
+   *
+   * @note It does not pop out the last item in the stack.
+   * It returns an uninitialized item handle if there is no item or only one item in the stack.
+   */
+  Actor Pop();
+
+
+public: // Not intended for application developers
+
+/// @cond internal
+  /**
+   * Creates a handle using the Toolkit::Internal implementation.
+   * @param[in]  implementation  The Control implementation.
+   */
+  DALI_INTERNAL NavigationView( Internal::NavigationView& implementation );
+
+  /**
+   * Allows the creation of this Control from an Internal::CustomActor pointer.
+   * @param[in]  internal  A pointer to the internal CustomActor.
+   */
+  explicit DALI_INTERNAL NavigationView( Dali::Internal::CustomActor* internal );
+/// @endcond
+}; // class NavigationView
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_NAVIGATION_VIEW_H
index 7cc6a2c..188ed1b 100755 (executable)
@@ -8,6 +8,7 @@ devel_api_src_files = \
   $(devel_api_src_dir)/controls/bubble-effect/bubble-emitter.cpp \
   $(devel_api_src_dir)/controls/effects-view/effects-view.cpp \
   $(devel_api_src_dir)/controls/magnifier/magnifier.cpp \
+  $(devel_api_src_dir)/controls/navigation-view/navigation-view.cpp \
   $(devel_api_src_dir)/controls/page-turn-view/page-turn-landscape-view.cpp \
   $(devel_api_src_dir)/controls/page-turn-view/page-turn-portrait-view.cpp \
   $(devel_api_src_dir)/controls/page-turn-view/page-turn-view.cpp \
@@ -53,6 +54,9 @@ devel_api_effects_view_header_files = \
 devel_api_magnifier_header_files = \
   $(devel_api_src_dir)/controls/magnifier/magnifier.h
 
+devel_api_navigation_view_header_files = \
+  $(devel_api_src_dir)/controls/navigation-view/navigation-view.h
+
 devel_api_page_turn_view_header_files = \
   $(devel_api_src_dir)/controls/page-turn-view/page-factory.h \
   $(devel_api_src_dir)/controls/page-turn-view/page-turn-landscape-view.h \
diff --git a/dali-toolkit/internal/controls/navigation-view/navigation-view-impl.cpp b/dali-toolkit/internal/controls/navigation-view/navigation-view-impl.cpp
new file mode 100644 (file)
index 0000000..1d15650
--- /dev/null
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include "navigation-view-impl.h"
+
+// EXTERNAL INCLUDES
+#include <dali/public-api/object/type-registry-helper.h>
+
+// INTERNAL INCLUDES
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+namespace Internal
+{
+
+namespace // to register type
+{
+
+BaseHandle Create()
+{
+  return Toolkit::NavigationView::New();
+}
+
+DALI_TYPE_REGISTRATION_BEGIN( Toolkit::NavigationView, Toolkit::Control, Create )
+DALI_TYPE_REGISTRATION_END()
+
+} // namespace
+
+NavigationView::NavigationView()
+: Control(ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) )
+{
+}
+
+NavigationView::~NavigationView()
+{
+  // Clear all the items in the stack, forces their destruction before NavigationView is destroyed.
+  mContentStack.clear();
+}
+
+Toolkit::NavigationView NavigationView::New()
+{
+  // Create the implementation, temporarily owned by this handle on stack
+  IntrusivePtr< NavigationView > internalNavigationView = new NavigationView();
+
+  // Pass ownership to CustomActor handle
+  Toolkit::NavigationView navigationView( *internalNavigationView );
+
+  // Second-phase init of the implementation
+  // This can only be done after the CustomActor connection has been made...
+  internalNavigationView->Initialize();
+
+  return navigationView;
+}
+
+void NavigationView::OnStageConnection( int depth )
+{
+  Self().SetSensitive(true);
+}
+
+void NavigationView::Push( Actor& actor )
+{
+  // check the uninitialized item
+  // check the duplicated push for the top item
+  if(!actor )
+  {
+    return;
+  }
+
+  if( mContentStack.size() > 0 )
+  {
+    Self().Remove( mContentStack.back()  );
+  }
+
+  //push the new item into the stack and show it
+  mContentStack.push_back(actor);
+  Self().Add(actor);
+}
+
+Actor NavigationView::Pop()
+{
+  // cannot pop out the bottom-most item
+  Actor poppedItem;
+  if( mContentStack.size() > 1 )
+  {
+    // pop out the top item of the stack and show the new item right under the old one.
+    Self().Remove(mContentStack.back());
+    poppedItem = mContentStack.back();
+    mContentStack.pop_back();
+    Self().Add(mContentStack.back());
+  }
+
+  return poppedItem;
+}
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
diff --git a/dali-toolkit/internal/controls/navigation-view/navigation-view-impl.h b/dali-toolkit/internal/controls/navigation-view/navigation-view-impl.h
new file mode 100644 (file)
index 0000000..c6d9160
--- /dev/null
@@ -0,0 +1,142 @@
+#ifndef __DALI_TOOLKIT_INTERNAL_NAVIGATION_CONTROL_H__
+#define __DALI_TOOLKIT_INTERNAL_NAVIGATION_CONTROL_H__
+
+/*
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <list>
+#include <dali/public-api/actors/layer.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/public-api/controls/control-impl.h>
+#include <dali-toolkit/devel-api/controls/navigation-view/navigation-view.h>
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+class NavigationView;
+
+namespace Internal
+{
+
+class NavigationBar;
+
+/**
+ * @brief
+ *
+ * NavigationView implements a controller than manages the navigation of hierarchical contents.
+ */
+
+class NavigationView : public Control
+{
+public:
+
+  /**
+   * Create an initialized NavigationView.
+   * @return A handle to a newly allocated Dali resource
+   */
+  static Toolkit::NavigationView New();
+
+  /**
+   * @copydoc Dali::Toolkit::NavigationView::Push()
+   */
+  void Push( Actor& actor );
+
+  /**
+   * @copydoc Dali::Toolkit::NavigationView::Pop()
+   */
+  Actor Pop();
+
+  /**
+   * Performs actions as requested using the action name.
+   * @param[in] object The object on which to perform the action.
+   * @param[in] actionName The action to perform.
+   * @param[in] properties The properties with which to perform this action.
+   * @return true if action has been accepted by this control
+   */
+  //static bool DoAction( BaseObject* object, const std::string& actionName, const Property::Map& properties );
+
+
+private: // override functions from Control
+
+  /**
+   * @copydoc Control::OnStageConnection( int depth  )
+   */
+  virtual void OnStageConnection( int depth );
+
+  /**
+   * @copydoc Control::OnRelayout()
+   */
+  //virtual void OnRelayout( const Vector2& size, RelayoutContainer& container );
+
+protected:
+
+  /**
+   * Constructor.
+   * It initializes the NavigationView members
+   */
+  NavigationView();
+
+  /**
+   * A reference counted object may only be deleted by calling Unreference()
+   */
+  virtual ~NavigationView();
+
+private:
+
+  // Undefined
+  NavigationView(const NavigationView&);
+
+  // Undefined
+  NavigationView& operator=(const NavigationView& rhs);
+
+private:
+
+  std::vector< Actor >         mContentStack;
+};
+
+} // namespace Internal
+
+// Helpers for public-api forwarding methods
+
+inline Toolkit::Internal::NavigationView& GetImpl( Toolkit::NavigationView& navigationView )
+{
+  DALI_ASSERT_ALWAYS( navigationView );
+
+  Dali::RefObject& handle = navigationView.GetImplementation();
+
+  return static_cast<Toolkit::Internal::NavigationView&>( handle );
+}
+
+inline const Toolkit::Internal::NavigationView& GetImpl( const Toolkit::NavigationView& navigationView )
+{
+  DALI_ASSERT_ALWAYS( navigationView );
+
+  const Dali::RefObject& handle = navigationView.GetImplementation();
+
+  return static_cast<const Toolkit::Internal::NavigationView&>( handle );
+}
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif /* __DALI_TOOLKIT_INTERNAL_NAVIGATION_CONTROL_H__ */
index 7fb2109..5a52371 100644 (file)
@@ -43,6 +43,7 @@ toolkit_src_files = \
    $(toolkit_src_dir)/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp \
    $(toolkit_src_dir)/controls/image-view/image-view-impl.cpp \
    $(toolkit_src_dir)/controls/magnifier/magnifier-impl.cpp \
+   $(toolkit_src_dir)/controls/navigation-view/navigation-view-impl.cpp \
    $(toolkit_src_dir)/controls/popup/confirmation-popup-impl.cpp \
    $(toolkit_src_dir)/controls/model3d-view/model3d-view-impl.cpp \
    $(toolkit_src_dir)/controls/model3d-view/obj-loader.cpp \
diff --git a/packaging/dali-csharp-wrapper.spec b/packaging/dali-csharp-wrapper.spec
new file mode 100755 (executable)
index 0000000..dca178a
--- /dev/null
@@ -0,0 +1,149 @@
+Name:       NDalic
+Summary:    dali wrapper
+Version:    1.0.0
+Release:    1
+Group:      uifw/graphic
+License:    TO_BE_FILLED_IN
+Source0:    %{name}-%{version}.tar.gz
+BuildRequires: cmake
+BuildRequires: swig
+#BuildRequires: ruby
+#BuildRequires: ruby-devel
+
+#BuildRequires: mono-core
+#BuildRequires: mono-compat
+#BuildRequires: mono-data
+#BuildRequires: mono-compiler
+#BuildRequires: mono-wcf
+#BuildRequires: mono-web
+
+BuildRequires:  pkgconfig
+
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(dali-core)
+BuildRequires: pkgconfig(dali-adaptor)
+BuildRequires: pkgconfig(dali-toolkit)
+
+BuildRequires: dali-devel
+BuildRequires: dali-integration-devel
+BuildRequires: dali-adaptor-devel
+BuildRequires: dali-adaptor-integration-devel
+BuildRequires: dali-toolkit-devel
+
+
+%description
+dali wrapper
+
+%package dali-wrapper
+
+Summary: Development dali-wrapper
+Group: Development/Libraries/Other
+Requires: %{name} = %{version}
+
+%description dali-wrapper
+Development .so for dali wrapper
+%define daliSwigDir %{_builddir}/%{name}-%{version}/build/tizen
+%define daliToolkitDir %{_builddir}/dali-toolkit-%{version}/build/tizen
+%define daliPluginsDir %{_builddir}/%{name}-%{version}/build/tizen/plugins/csharp
+
+#############################
+# profile setup
+#############################
+
+
+%define dali_toolkit_profile MOBILE
+
+%define dali_style_folder 720x1280
+# dali_style to be provided by build system as with dali_toolkit_profile or by passing --define 'dali_style 470x800' to the rpm build command
+
+%if "%{?dali_style}"
+  %define dali_style_folder %{dali_style}
+%endif
+
+# Further resource locations profiles can be provided here otherwise MOBILE will be used
+%if "%{tizen_profile_name}" == "mobile"
+  %define dali_toolkit_profile MOBILE
+%endif
+
+%description
+The OpenGLES Canvas Core Library Toolkit - a set of controls that provide
+user interface functionality.
+
+##############################
+# Preparation
+##############################
+%prep
+%setup -q
+
+#Use TZ_PATH when tizen version is 3.x
+
+%if "%{tizen_version_major}" == "2"
+%define ndali_data_rw_dir            /opt/usr/share/dali/
+%define ndali_data_ro_dir            /usr/share/dali/
+%else
+%define ndali_data_rw_dir            %TZ_SYS_SHARE/dali/
+%define ndali_data_ro_dir            %TZ_SYS_RO_SHARE/dali/
+%endif
+##############################
+# Build
+##############################
+%build
+echo "----------------" %{_builddir}
+echo "----------------" %{daliSwigDir}
+echo "----------------" %{_libdir}
+echo "----------------" %{daliPluginsDir}
+
+PREFIX="/usr"
+CXXFLAGS+=" -Wall -g -Os -fPIC -fvisibility-inlines-hidden -fdata-sections -ffunction-sections "
+LDFLAGS+=" -Wl,--rpath=$PREFIX/lib -Wl,--as-needed -Wl,--gc-sections -Wl,-Bsymbolic-functions "
+
+%if 0%{?enable_coverage}
+CXXFLAGS+=" --coverage "
+LDFLAGS+=" --coverage "
+%endif
+
+
+##############################
+# Build dali-wrap
+##############################
+
+libtoolize --force
+cd %{daliSwigDir}
+autoreconf --install
+NDALI_DATA_RW_DIR="%{ndali_data_rw_dir}" ; export NDALI_DATA_RW_DIR
+NDALI_DATA_RO_DIR="%{ndali_data_ro_dir}" ; export NDALI_DATA_RO_DIR
+%configure --enable-profile=%{dali_toolkit_profile} \
+           --with-style=%{dali_style_folder} \
+           --enable-csharp=yes \
+%if 0%{?enable_debug}
+           --enable-debug \
+%endif
+           --enable-i18n=yes
+cd %{daliPluginsDir}
+make gbs-local
+
+##############################
+# Installation
+##############################
+echo "----------------" %{_buildrootdir}
+%install
+cd "%{daliPluginsDir}"
+make DESTDIR=%{_buildrootdir}/%{name}-%{version}-%{release}.arm/usr/lib/ gbs-install
+
+#mv %{_builddir}/%{name}-%{version}/plugins/dali-swig/NDali.dll %{_buildrootdir}/%{name}-%{version}-%{release}.arm/usr/lib/
+
+##############################
+# Post Install
+##############################
+%post
+
+
+##############################
+# Files in Binary Packages
+##############################
+%files
+%manifest dali-csharp-wrapper.manifest
+%defattr(-,root,root,-)
+%{_libdir}/lib*
+%{_libdir}/NDali.dll
+
diff --git a/plugins/dali-swig/NDali.dll b/plugins/dali-swig/NDali.dll
new file mode 100755 (executable)
index 0000000..34c673b
Binary files /dev/null and b/plugins/dali-swig/NDali.dll differ
old mode 100644 (file)
new mode 100755 (executable)
index affa265..3ce308e
@@ -25,6 +25,7 @@
 %include <dali/public-api/adaptor-framework/style-change.h>
 %include <dali/public-api/adaptor-framework/timer.h>
 %include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
+%include <dali/devel-api/adaptor-framework/application-extensions.h>
 %include <dali/public-api/adaptor-framework/window.h>
 
 #if defined(SWIGCSHARP)
old mode 100644 (file)
new mode 100755 (executable)
index 781a4ba..e76ba22
@@ -57,6 +57,7 @@
 #include <dali/public-api/adaptor-framework/window.h>
 #include <dali/public-api/adaptor-framework/style-change.h>
 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
+#include <dali/devel-api/adaptor-framework/application-extensions.h>
 
 #include <dali/devel-api/images/nine-patch-image.h>
 
index f28e3ca..64e070d 100644 (file)
       if (_accessibilityManagerStatusChangedEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerStatusChangedEventHandler(this, e, true);
+        return _accessibilityManagerStatusChangedEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionNextEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionNextEventHandler(this, e, true);
+        return _accessibilityManagerActionNextEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionPreviousEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionPreviousEventHandler(this, e, true);
+        return _accessibilityManagerActionPreviousEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionActivateEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionActivateEventHandler(this, e, true);
+        return _accessibilityManagerActionActivateEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadEventHandler(this, e, true);
+        return _accessibilityManagerActionReadEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionOverEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionOverEventHandler(this, e, true);
+        return _accessibilityManagerActionOverEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadNextEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadNextEventHandler(this, e, true);
+        return _accessibilityManagerActionReadNextEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadPreviousEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadPreviousEventHandler(this, e, true);
+        return _accessibilityManagerActionReadPreviousEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionUpEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionUpEventHandler(this, e, true);
+        return _accessibilityManagerActionUpEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionDownEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionDownEventHandler(this, e, true);
+        return _accessibilityManagerActionDownEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionClearFocusEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionClearFocusEventHandler(this, e, true);
+        return _accessibilityManagerActionClearFocusEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionBackEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionBackEventHandler(this, e, true);
+        return _accessibilityManagerActionBackEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionScrollUpEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionScrollUpEventHandler(this, e, true);
+        return _accessibilityManagerActionScrollUpEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionScrollDownEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionScrollDownEventHandler(this, e, true);
+        return _accessibilityManagerActionScrollDownEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionPageLeftEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionPageLeftEventHandler(this, e, true);
+        return _accessibilityManagerActionPageLeftEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionPageRightEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionPageRightEventHandler(this, e, true);
+        return _accessibilityManagerActionPageRightEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionPageUpEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionPageUpEventHandler(this, e, true);
+        return _accessibilityManagerActionPageUpEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionPageDownEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionPageDownEventHandler(this, e, true);
+        return _accessibilityManagerActionPageDownEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionMoveToFirstEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionMoveToFirstEventHandler(this, e, true);
+        return _accessibilityManagerActionMoveToFirstEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionMoveToLastEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionMoveToLastEventHandler(this, e, true);
+        return _accessibilityManagerActionMoveToLastEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadFromTopEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadFromTopEventHandler(this, e, true);
+        return _accessibilityManagerActionReadFromTopEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadFromNextEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadFromNextEventHandler(this, e, true);
+        return _accessibilityManagerActionReadFromNextEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionZoomEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionZoomEventHandler(this, e, true);
+        return _accessibilityManagerActionZoomEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadIndicatorInformationEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e, true);
+        return _accessibilityManagerActionReadIndicatorInformationEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionReadPauseResumeEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionReadPauseResumeEventHandler(this, e, true);
+        return _accessibilityManagerActionReadPauseResumeEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionStartStopEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionStartStopEventHandler(this, e, true);
+        return _accessibilityManagerActionStartStopEventHandler(this, e);
       }
       return false;
     }
       if (_accessibilityManagerActionScrollEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _accessibilityManagerActionScrollEventHandler(this, e, true);
+        return _accessibilityManagerActionScrollEventHandler(this, e);
       }
       return false;
     }
index 1a4b05a..4a5f51f 100644 (file)
       if (_actorTouchDataEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _actorTouchDataEventHandler(this, e, true);
+        return _actorTouchDataEventHandler(this, e);
       }
 
       return false;
       if (_actorHoverEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _actorHoverEventHandler(this, e, true);
+        return _actorHoverEventHandler(this, e);
       }
 
       return false;
       if (_actorWheelEventHandler != null)
       {
         //here we send all data to user event handlers
-        return _actorWheelEventHandler(this, e, true);
+        return _actorWheelEventHandler(this, e);
       }
 
       return false;
index e568870..bfef5ad 100644 (file)
@@ -160,7 +160,7 @@ public class StateChangedEventArgs : EventArgs
      if (_buttonClickedEventHandler != null)
      {
         //here we send all data to user event handlers
-        return _buttonClickedEventHandler(this, e,true);
+        return _buttonClickedEventHandler(this, e);
      }
      return false;
   }
@@ -207,7 +207,7 @@ public class StateChangedEventArgs : EventArgs
      if (_buttonPressedEventHandler != null)
      {
         //here we send all data to user event handlers
-       return _buttonPressedEventHandler(this, e,true);
+       return _buttonPressedEventHandler(this, e);
      }
      return false;
   }
@@ -254,7 +254,7 @@ public class StateChangedEventArgs : EventArgs
      if (_buttonReleasedEventHandler != null)
      {
         //here we send all data to user event handlers
-       return _buttonReleasedEventHandler(this, e, true);
+       return _buttonReleasedEventHandler(this, e);
      }
      return false;
   }
@@ -301,7 +301,7 @@ public class StateChangedEventArgs : EventArgs
      if (_buttonStateChangedEventHandler != null)
      {
         //here we send all data to user event handlers
-       return _buttonStateChangedEventHandler(this, e, true);
+       return _buttonStateChangedEventHandler(this, e);
      }
      return false;
   }
index 83eb9c4..9f7d02f 100644 (file)
@@ -283,7 +283,7 @@ public class KeyEventArgs : EventArgs
    if (_KeyEventHandler != null)
    {
       //here we send all data to user event handlers
-      return _KeyEventHandler(this, e, true);
+      return _KeyEventHandler(this, e);
    }
    return false;
 
index 53906d6..02ef3da 100644 (file)
@@ -175,7 +175,7 @@ public class MarkReachedEventArgs : EventArgs
      if (_sliderValueChangedEventHandler != null)
      {
         //here we send all page to user event handlers
-      return _sliderValueChangedEventHandler(this, e, true);
+      return _sliderValueChangedEventHandler(this, e);
      }
      return false;
   }
@@ -223,7 +223,7 @@ public class MarkReachedEventArgs : EventArgs
      if (_sliderSlidingFinishedEventHandler != null)
      {
         //here we send all page to user event handlers
-      return _sliderSlidingFinishedEventHandler(this, e, true);
+      return _sliderSlidingFinishedEventHandler(this, e);
      }
      return false;
   }
@@ -271,7 +271,7 @@ public class MarkReachedEventArgs : EventArgs
      if (_sliderMarkReachedEventHandler != null)
      {
         //here we send all page to user event handlers
-      return _sliderMarkReachedEventHandler(this, e, true);
+      return _sliderMarkReachedEventHandler(this, e);
      }
      return false;
   }
index e6fb89a..1604a08 100644 (file)
@@ -83,7 +83,7 @@ using System.Runtime.InteropServices;
      if (_timerTickEventHandler != null)
      {
         //here we send all data to user event handlers
-        return _timerTickEventHandler(this, e, true);
+        return _timerTickEventHandler(this, e);
      }
      return false;
   }
diff --git a/plugins/dali-swig/automatic/cpp/dali_wrap.cpp b/plugins/dali-swig/automatic/cpp/dali_wrap.cpp
new file mode 100644 (file)
index 0000000..5bff0ef
--- /dev/null
@@ -0,0 +1,88355 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 3.0.9
+ *
+ * This file is not intended to be easily readable and contains a number of
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG
+ * interface file instead.
+ * ----------------------------------------------------------------------------- */
+
+
+#ifndef SWIGCSHARP
+#define SWIGCSHARP
+#endif
+
+#define SWIG_DIRECTORS
+
+
+#ifdef __cplusplus
+/* SwigValueWrapper is described in swig.swg */
+template<typename T> class SwigValueWrapper {
+  struct SwigMovePointer {
+    T *ptr;
+    SwigMovePointer(T *p) : ptr(p) { }
+    ~SwigMovePointer() { delete ptr; }
+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
+  } pointer;
+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
+public:
+  SwigValueWrapper() : pointer(0) { }
+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
+  operator T&() const { return *pointer.ptr; }
+  T *operator&() { return pointer.ptr; }
+};
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
+#endif
+
+/* -----------------------------------------------------------------------------
+ *  This section contains generic SWIG labels for method/variable
+ *  declarations/attributes, and other compiler dependent labels.
+ * ----------------------------------------------------------------------------- */
+
+/* template workaround for compilers that cannot correctly implement the C++ standard */
+#ifndef SWIGTEMPLATEDISAMBIGUATOR
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# else
+#  define SWIGTEMPLATEDISAMBIGUATOR
+# endif
+#endif
+
+/* inline attribute */
+#ifndef SWIGINLINE
+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
+#   define SWIGINLINE inline
+# else
+#   define SWIGINLINE
+# endif
+#endif
+
+/* attribute recognised by some compilers to avoid 'unused' warnings */
+#ifndef SWIGUNUSED
+# if defined(__GNUC__)
+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+#     define SWIGUNUSED __attribute__ ((__unused__))
+#   else
+#     define SWIGUNUSED
+#   endif
+# elif defined(__ICC)
+#   define SWIGUNUSED __attribute__ ((__unused__))
+# else
+#   define SWIGUNUSED
+# endif
+#endif
+
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif
+#endif
+
+#ifndef SWIGUNUSEDPARM
+# ifdef __cplusplus
+#   define SWIGUNUSEDPARM(p)
+# else
+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
+# endif
+#endif
+
+/* internal SWIG method */
+#ifndef SWIGINTERN
+# define SWIGINTERN static SWIGUNUSED
+#endif
+
+/* internal inline SWIG method */
+#ifndef SWIGINTERNINLINE
+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
+#endif
+
+/* exporting methods */
+#if defined(__GNUC__)
+#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
+#    ifndef GCC_HASCLASSVISIBILITY
+#      define GCC_HASCLASSVISIBILITY
+#    endif
+#  endif
+#endif
+
+#ifndef SWIGEXPORT
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   if defined(STATIC_LINKED)
+#     define SWIGEXPORT
+#   else
+#     define SWIGEXPORT __declspec(dllexport)
+#   endif
+# else
+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
+#     define SWIGEXPORT __attribute__ ((visibility("default")))
+#   else
+#     define SWIGEXPORT
+#   endif
+# endif
+#endif
+
+/* calling conventions for Windows */
+#ifndef SWIGSTDCALL
+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#   define SWIGSTDCALL __stdcall
+# else
+#   define SWIGSTDCALL
+# endif
+#endif
+
+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
+# define _CRT_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
+#endif
+
+/* Intel's compiler complains if a variable which was never initialised is
+ * cast to void, which is a common idiom which we use to indicate that we
+ * are aware a variable isn't used.  So we just silence that warning.
+ * See: https://github.com/swig/swig/issues/192 for more discussion.
+ */
+#ifdef __INTEL_COMPILER
+# pragma warning disable 592
+#endif
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+
+/* Support for throwing C# exceptions from C/C++. There are two types: 
+ * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
+typedef enum {
+  SWIG_CSharpApplicationException,
+  SWIG_CSharpArithmeticException,
+  SWIG_CSharpDivideByZeroException,
+  SWIG_CSharpIndexOutOfRangeException,
+  SWIG_CSharpInvalidCastException,
+  SWIG_CSharpInvalidOperationException,
+  SWIG_CSharpIOException,
+  SWIG_CSharpNullReferenceException,
+  SWIG_CSharpOutOfMemoryException,
+  SWIG_CSharpOverflowException,
+  SWIG_CSharpSystemException
+} SWIG_CSharpExceptionCodes;
+
+typedef enum {
+  SWIG_CSharpArgumentException,
+  SWIG_CSharpArgumentNullException,
+  SWIG_CSharpArgumentOutOfRangeException
+} SWIG_CSharpExceptionArgumentCodes;
+
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
+typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
+
+typedef struct {
+  SWIG_CSharpExceptionCodes code;
+  SWIG_CSharpExceptionCallback_t callback;
+} SWIG_CSharpException_t;
+
+typedef struct {
+  SWIG_CSharpExceptionArgumentCodes code;
+  SWIG_CSharpExceptionArgumentCallback_t callback;
+} SWIG_CSharpExceptionArgument_t;
+
+static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
+  { SWIG_CSharpApplicationException, NULL },
+  { SWIG_CSharpArithmeticException, NULL },
+  { SWIG_CSharpDivideByZeroException, NULL },
+  { SWIG_CSharpIndexOutOfRangeException, NULL },
+  { SWIG_CSharpInvalidCastException, NULL },
+  { SWIG_CSharpInvalidOperationException, NULL },
+  { SWIG_CSharpIOException, NULL },
+  { SWIG_CSharpNullReferenceException, NULL },
+  { SWIG_CSharpOutOfMemoryException, NULL },
+  { SWIG_CSharpOverflowException, NULL },
+  { SWIG_CSharpSystemException, NULL }
+};
+
+static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
+  { SWIG_CSharpArgumentException, NULL },
+  { SWIG_CSharpArgumentNullException, NULL },
+  { SWIG_CSharpArgumentOutOfRangeException, NULL }
+};
+
+static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
+  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
+  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
+    callback = SWIG_csharp_exceptions[code].callback;
+  }
+  callback(msg);
+}
+
+static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
+  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
+  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
+    callback = SWIG_csharp_exceptions_argument[code].callback;
+  }
+  callback(msg, param_name);
+}
+
+
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
+                                                SWIG_CSharpExceptionCallback_t applicationCallback,
+                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
+                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
+                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
+                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
+                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
+                                                SWIG_CSharpExceptionCallback_t ioCallback,
+                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
+                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
+                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
+                                                SWIG_CSharpExceptionCallback_t systemCallback) {
+  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
+  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
+}
+
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
+                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
+                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
+                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
+  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
+  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
+  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
+}
+
+
+/* Callback for returning strings to C# without leaking memory */
+typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
+static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
+
+
+#ifdef __cplusplus
+extern "C" 
+#endif
+SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
+  SWIG_csharp_string_callback = callback;
+}
+
+
+/* Contract support */
+
+#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
+
+/*  Errors in SWIG */
+#define  SWIG_UnknownError        -1
+#define  SWIG_IOError             -2
+#define  SWIG_RuntimeError        -3
+#define  SWIG_IndexError          -4
+#define  SWIG_TypeError           -5
+#define  SWIG_DivisionByZero      -6
+#define  SWIG_OverflowError       -7
+#define  SWIG_SyntaxError         -8
+#define  SWIG_ValueError          -9
+#define  SWIG_SystemError         -10
+#define  SWIG_AttributeError      -11
+#define  SWIG_MemoryError         -12
+#define  SWIG_NullReferenceError   -13
+
+
+
+/* -----------------------------------------------------------------------------
+ * director_common.swg
+ *
+ * This file contains support for director classes which is common between
+ * languages.
+ * ----------------------------------------------------------------------------- */
+
+/*
+  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
+  'Swig' namespace. This could be useful for multi-modules projects.
+*/
+#ifdef SWIG_DIRECTOR_STATIC
+/* Force anonymous (static) namespace */
+#define Swig
+#endif
+/* -----------------------------------------------------------------------------
+ * director.swg
+ *
+ * This file contains support for director classes so that C# proxy
+ * methods can be called from C++.
+ * ----------------------------------------------------------------------------- */
+
+#if defined(DEBUG_DIRECTOR_OWNED)
+#include <iostream>
+#endif
+#include <string>
+#include <exception>
+
+namespace Swig {
+  /* Director base class - not currently used in C# directors */
+  class Director {
+  };
+
+  /* Base class for director exceptions */
+  class DirectorException : public std::exception {
+  protected:
+    std::string swig_msg;
+
+  public:
+    DirectorException(const char *msg) : swig_msg(msg) {
+    }
+
+    DirectorException(const std::string &msg) : swig_msg(msg) {
+    }
+
+    virtual ~DirectorException() throw() {
+    }
+
+    const char *what() const throw() {
+      return swig_msg.c_str();
+    }
+  };
+
+  /* Pure virtual method exception */
+  class DirectorPureVirtualException : public DirectorException {
+  public:
+    DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
+    }
+  };
+}
+
+
+SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
+  if (code == SWIG_ValueError) {
+    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
+    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
+  } else {
+    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
+    switch(code) {
+    case SWIG_MemoryError:
+      exception_code = SWIG_CSharpOutOfMemoryException;
+      break;
+    case SWIG_IndexError:
+      exception_code = SWIG_CSharpIndexOutOfRangeException;
+      break;
+    case SWIG_DivisionByZero:
+      exception_code = SWIG_CSharpDivideByZeroException;
+      break;
+    case SWIG_IOError:
+      exception_code = SWIG_CSharpIOException;
+      break;
+    case SWIG_OverflowError:
+      exception_code = SWIG_CSharpOverflowException;
+      break;
+    case SWIG_RuntimeError:
+    case SWIG_TypeError:
+    case SWIG_SyntaxError:
+    case SWIG_SystemError:
+    case SWIG_UnknownError:
+    default:
+      exception_code = SWIG_CSharpApplicationException;
+      break;
+    }
+    SWIG_CSharpSetPendingException(exception_code, msg);
+  }
+}
+
+
+#include <stdexcept>
+
+
+#define SWIGSTDCALL
+
+
+#include <dali/dali.h>
+#include <dali-toolkit/dali-toolkit.h>
+
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/matrix3.h>
+#include <dali/public-api/math/viewport.h>
+#include <dali/public-api/object/property-key.h>
+
+#include <dali/public-api/adaptor-framework/timer.h>
+#include <dali/public-api/adaptor-framework/window.h>
+#include <dali/public-api/adaptor-framework/style-change.h>
+#include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
+
+#include <dali/devel-api/images/nine-patch-image.h>
+
+#include <dali-toolkit/devel-api/builder/builder.h>
+#include <dali-toolkit/devel-api/controls/popup/popup.h>
+#include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
+#include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
+#include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
+
+#include <dali-toolkit/devel-api/visual-factory/visual-base.h>
+#include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
+
+#include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
+
+// add here SWIG version check
+
+#if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
+// disable Swig-dependent warnings
+
+// 'identifier1' has C-linkage specified,
+// but returns UDT 'identifier2' which is incompatible with C
+#pragma warning(disable: 4190)
+
+// 'int' : forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable: 4800)
+
+// debug info too long etc etc
+#pragma warning(disable: 4786)
+#endif
+
+
+#include <stdexcept>
+
+
+#include <string>
+
+
+#include <vector>
+#include <algorithm>
+#include <stdexcept>
+
+
+#include <map>
+#include <algorithm>
+#include <stdexcept>
+
+
+#include <utility>
+
+
+typedef float floatp;
+
+SWIGINTERN floatp *new_floatp(){
+  return new float();
+}
+SWIGINTERN void delete_floatp(floatp *self){
+  if (self) delete self;
+}
+SWIGINTERN void floatp_assign(floatp *self,float value){
+  *self = value;
+}
+SWIGINTERN float floatp_value(floatp *self){
+  return *self;
+}
+SWIGINTERN float *floatp_cast(floatp *self){
+  return self;
+}
+SWIGINTERN floatp *floatp_frompointer(float *t){
+  return (floatp *) t;
+}
+
+typedef int intp;
+
+SWIGINTERN intp *new_intp(){
+  return new int();
+}
+SWIGINTERN void delete_intp(intp *self){
+  if (self) delete self;
+}
+SWIGINTERN void intp_assign(intp *self,int value){
+  *self = value;
+}
+SWIGINTERN int intp_value(intp *self){
+  return *self;
+}
+SWIGINTERN int *intp_cast(intp *self){
+  return self;
+}
+SWIGINTERN intp *intp_frompointer(int *t){
+  return (intp *) t;
+}
+
+typedef double doublep;
+
+SWIGINTERN doublep *new_doublep(){
+  return new double();
+}
+SWIGINTERN void delete_doublep(doublep *self){
+  if (self) delete self;
+}
+SWIGINTERN void doublep_assign(doublep *self,double value){
+  *self = value;
+}
+SWIGINTERN double doublep_value(doublep *self){
+  return *self;
+}
+SWIGINTERN double *doublep_cast(doublep *self){
+  return self;
+}
+SWIGINTERN doublep *doublep_frompointer(double *t){
+  return (doublep *) t;
+}
+
+typedef unsigned int uintp;
+
+SWIGINTERN uintp *new_uintp(){
+  return new unsigned int();
+}
+SWIGINTERN void delete_uintp(uintp *self){
+  if (self) delete self;
+}
+SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
+  *self = value;
+}
+SWIGINTERN unsigned int uintp_value(uintp *self){
+  return *self;
+}
+SWIGINTERN unsigned int *uintp_cast(uintp *self){
+  return self;
+}
+SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
+  return (uintp *) t;
+}
+
+typedef unsigned short ushortp;
+
+SWIGINTERN ushortp *new_ushortp(){
+  return new unsigned short();
+}
+SWIGINTERN void delete_ushortp(ushortp *self){
+  if (self) delete self;
+}
+SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
+  *self = value;
+}
+SWIGINTERN unsigned short ushortp_value(ushortp *self){
+  return *self;
+}
+SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
+  return self;
+}
+SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
+  return (ushortp *) t;
+}
+
+unsigned int int_to_uint(int x) {
+   return (unsigned int) x;
+}
+
+
+using namespace Dali;
+using namespace Dali::Toolkit;
+
+SWIGINTERN bool Dali_BaseHandle_IsHandleEmpty(Dali::BaseHandle const *self){
+     if( *self )
+     {
+       return true;
+     }
+     else
+     {
+       return false;
+     }
+    }
+SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
+        std::vector< Dali::TouchPoint >* pv = 0;
+        if (capacity >= 0) {
+          pv = new std::vector< Dali::TouchPoint >();
+          pv->reserve(capacity);
+       } else {
+          throw std::out_of_range("capacity");
+       }
+       return pv;
+      }
+SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
+        if (index>=0 && index<(int)self->size())
+          (*self)[index] = val;
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
+        self->insert(self->end(), values.begin(), values.end());
+      }
+SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, x);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, values.begin(), values.end());
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          self->erase(self->begin() + index);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        self->erase(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
+        if (count < 0)
+          throw std::out_of_range("count");
+        return new std::vector< Dali::TouchPoint >(count, value);
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
+        std::reverse(self->begin(), self->end());
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        std::reverse(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (index+values.size() > self->size())
+          throw std::out_of_range("index");
+        std::copy(values.begin(), values.end(), self->begin()+index);
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
+        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_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+
+  // keep argcs and argv so they're always available to DALi
+  int argC = 1;
+  char **argV = NULL;
+
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
+        std::vector< unsigned int >* pv = 0;
+        if (capacity >= 0) {
+          pv = new std::vector< unsigned int >();
+          pv->reserve(capacity);
+       } else {
+          throw std::out_of_range("capacity");
+       }
+       return pv;
+      }
+SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
+        if (index>=0 && index<(int)self->size())
+          (*self)[index] = val;
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
+        self->insert(self->end(), values.begin(), values.end());
+      }
+SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, x);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, values.begin(), values.end());
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          self->erase(self->begin() + index);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        self->erase(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
+        if (count < 0)
+          throw std::out_of_range("count");
+        return new std::vector< unsigned int >(count, value);
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
+        std::reverse(self->begin(), self->end());
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        std::reverse(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (index+values.size() > self->size())
+          throw std::out_of_range("index");
+        std::copy(values.begin(), values.end(), self->begin()+index);
+      }
+SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
+        return std::find(self->begin(), self->end(), value) != self->end();
+      }
+SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
+        int index = -1;
+        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
+        if (it != self->end())
+          index = (int)(it - self->begin());
+        return index;
+      }
+SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
+        int index = -1;
+        std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
+        if (rit != self->rend())
+          index = (int)(self->rend() - 1 - rit);
+        return index;
+      }
+SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
+        std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
+        if (it != self->end()) {
+          self->erase(it);
+         return true;
+        }
+        return false;
+      }
+SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
+        std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
+        if (capacity >= 0) {
+          pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
+          pv->reserve(capacity);
+       } else {
+          throw std::out_of_range("capacity");
+       }
+       return pv;
+      }
+SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
+        if (index>=0 && index<(int)self->size())
+          (*self)[index] = val;
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
+        self->insert(self->end(), values.begin(), values.end());
+      }
+SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, x);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, values.begin(), values.end());
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          self->erase(self->begin() + index);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        self->erase(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
+        if (count < 0)
+          throw std::out_of_range("count");
+        return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
+        std::reverse(self->begin(), self->end());
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        std::reverse(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (index+values.size() > self->size())
+          throw std::out_of_range("index");
+        std::copy(values.begin(), values.end(), self->begin()+index);
+      }
+SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
+        std::vector< Dali::Actor >* pv = 0;
+        if (capacity >= 0) {
+          pv = new std::vector< Dali::Actor >();
+          pv->reserve(capacity);
+       } else {
+          throw std::out_of_range("capacity");
+       }
+       return pv;
+      }
+SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          return (*self)[index];
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
+        if (index>=0 && index<(int)self->size())
+          (*self)[index] = val;
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
+        self->insert(self->end(), values.begin(), values.end());
+      }
+SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, x);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
+        if (index>=0 && index<(int)self->size()+1)
+          self->insert(self->begin()+index, values.begin(), values.end());
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
+        if (index>=0 && index<(int)self->size())
+          self->erase(self->begin() + index);
+        else
+          throw std::out_of_range("index");
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        self->erase(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
+        if (count < 0)
+          throw std::out_of_range("count");
+        return new std::vector< Dali::Actor >(count, value);
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
+        std::reverse(self->begin(), self->end());
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (count < 0)
+          throw std::out_of_range("count");
+        if (index >= (int)self->size()+1 || index+count > (int)self->size())
+          throw std::invalid_argument("invalid range");
+        std::reverse(self->begin()+index, self->begin()+index+count);
+      }
+SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
+        if (index < 0)
+          throw std::out_of_range("index");
+        if (index+values.size() > self->size())
+          throw std::out_of_range("index");
+        std::copy(values.begin(), values.end(), self->begin()+index);
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
+          return self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &,Dali::TouchEvent const &) > *self,Dali::Toolkit::AccessibilityManager &arg1,Dali::TouchEvent const &arg2){
+        return self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
+        self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
+        /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
+          self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
+          return self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
+          return self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
+        self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
+        return self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
+          self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
+          self->Disconnect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
+          /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
+/*@SWIG@*/ self->Emit( arg );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
+        self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
+        return self->Emit( arg1, arg2 );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
+         return self->Empty();
+      }
+SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
+        return self->GetConnectionCount();
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
+        self->Connect( func );
+      }
+SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
+        self->Disconnect( func );
+      }
+SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
+        return self->Emit( arg1, arg2 );
+      }
+
+
+/* ---------------------------------------------------
+ * C++ director class methods
+ * --------------------------------------------------- */
+
+#include "dali_wrap.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
+  void * jresult ;
+  floatp *result = 0 ;
+  
+  {
+    try {
+      result = (floatp *)new_floatp();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
+  floatp *arg1 = (floatp *) 0 ;
+  
+  arg1 = (floatp *)jarg1; 
+  {
+    try {
+      delete_floatp(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
+  floatp *arg1 = (floatp *) 0 ;
+  float arg2 ;
+  
+  arg1 = (floatp *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      floatp_assign(arg1,arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
+  float jresult ;
+  floatp *arg1 = (floatp *) 0 ;
+  float result;
+  
+  arg1 = (floatp *)jarg1; 
+  {
+    try {
+      result = (float)floatp_value(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
+  void * jresult ;
+  floatp *arg1 = (floatp *) 0 ;
+  float *result = 0 ;
+  
+  arg1 = (floatp *)jarg1; 
+  {
+    try {
+      result = (float *)floatp_cast(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
+  void * jresult ;
+  float *arg1 = (float *) 0 ;
+  floatp *result = 0 ;
+  
+  arg1 = (float *)jarg1; 
+  {
+    try {
+      result = (floatp *)floatp_frompointer(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
+  void * jresult ;
+  intp *result = 0 ;
+  
+  {
+    try {
+      result = (intp *)new_intp();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
+  intp *arg1 = (intp *) 0 ;
+  
+  arg1 = (intp *)jarg1; 
+  {
+    try {
+      delete_intp(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
+  intp *arg1 = (intp *) 0 ;
+  int arg2 ;
+  
+  arg1 = (intp *)jarg1; 
+  arg2 = (int)jarg2; 
+  {
+    try {
+      intp_assign(arg1,arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
+  int jresult ;
+  intp *arg1 = (intp *) 0 ;
+  int result;
+  
+  arg1 = (intp *)jarg1; 
+  {
+    try {
+      result = (int)intp_value(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
+  void * jresult ;
+  intp *arg1 = (intp *) 0 ;
+  int *result = 0 ;
+  
+  arg1 = (intp *)jarg1; 
+  {
+    try {
+      result = (int *)intp_cast(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
+  void * jresult ;
+  int *arg1 = (int *) 0 ;
+  intp *result = 0 ;
+  
+  arg1 = (int *)jarg1; 
+  {
+    try {
+      result = (intp *)intp_frompointer(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
+  void * jresult ;
+  doublep *result = 0 ;
+  
+  {
+    try {
+      result = (doublep *)new_doublep();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
+  doublep *arg1 = (doublep *) 0 ;
+  
+  arg1 = (doublep *)jarg1; 
+  {
+    try {
+      delete_doublep(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
+  doublep *arg1 = (doublep *) 0 ;
+  double arg2 ;
+  
+  arg1 = (doublep *)jarg1; 
+  arg2 = (double)jarg2; 
+  {
+    try {
+      doublep_assign(arg1,arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
+  double jresult ;
+  doublep *arg1 = (doublep *) 0 ;
+  double result;
+  
+  arg1 = (doublep *)jarg1; 
+  {
+    try {
+      result = (double)doublep_value(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
+  void * jresult ;
+  doublep *arg1 = (doublep *) 0 ;
+  double *result = 0 ;
+  
+  arg1 = (doublep *)jarg1; 
+  {
+    try {
+      result = (double *)doublep_cast(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
+  void * jresult ;
+  double *arg1 = (double *) 0 ;
+  doublep *result = 0 ;
+  
+  arg1 = (double *)jarg1; 
+  {
+    try {
+      result = (doublep *)doublep_frompointer(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
+  void * jresult ;
+  uintp *result = 0 ;
+  
+  {
+    try {
+      result = (uintp *)new_uintp();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
+  uintp *arg1 = (uintp *) 0 ;
+  
+  arg1 = (uintp *)jarg1; 
+  {
+    try {
+      delete_uintp(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
+  uintp *arg1 = (uintp *) 0 ;
+  unsigned int arg2 ;
+  
+  arg1 = (uintp *)jarg1; 
+  arg2 = (unsigned int)jarg2; 
+  {
+    try {
+      uintp_assign(arg1,arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
+  unsigned int jresult ;
+  uintp *arg1 = (uintp *) 0 ;
+  unsigned int result;
+  
+  arg1 = (uintp *)jarg1; 
+  {
+    try {
+      result = (unsigned int)uintp_value(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
+  void * jresult ;
+  uintp *arg1 = (uintp *) 0 ;
+  unsigned int *result = 0 ;
+  
+  arg1 = (uintp *)jarg1; 
+  {
+    try {
+      result = (unsigned int *)uintp_cast(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
+  void * jresult ;
+  unsigned int *arg1 = (unsigned int *) 0 ;
+  uintp *result = 0 ;
+  
+  arg1 = (unsigned int *)jarg1; 
+  {
+    try {
+      result = (uintp *)uintp_frompointer(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
+  void * jresult ;
+  ushortp *result = 0 ;
+  
+  {
+    try {
+      result = (ushortp *)new_ushortp();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
+  ushortp *arg1 = (ushortp *) 0 ;
+  
+  arg1 = (ushortp *)jarg1; 
+  {
+    try {
+      delete_ushortp(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
+  ushortp *arg1 = (ushortp *) 0 ;
+  unsigned short arg2 ;
+  
+  arg1 = (ushortp *)jarg1; 
+  arg2 = (unsigned short)jarg2; 
+  {
+    try {
+      ushortp_assign(arg1,arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
+  unsigned short jresult ;
+  ushortp *arg1 = (ushortp *) 0 ;
+  unsigned short result;
+  
+  arg1 = (ushortp *)jarg1; 
+  {
+    try {
+      result = (unsigned short)ushortp_value(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
+  void * jresult ;
+  ushortp *arg1 = (ushortp *) 0 ;
+  unsigned short *result = 0 ;
+  
+  arg1 = (ushortp *)jarg1; 
+  {
+    try {
+      result = (unsigned short *)ushortp_cast(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
+  void * jresult ;
+  unsigned short *arg1 = (unsigned short *) 0 ;
+  ushortp *result = 0 ;
+  
+  arg1 = (unsigned short *)jarg1; 
+  {
+    try {
+      result = (ushortp *)ushortp_frompointer(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
+  unsigned int jresult ;
+  int arg1 ;
+  unsigned int result;
+  
+  arg1 = (int)jarg1; 
+  {
+    try {
+      result = (unsigned int)int_to_uint(arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
+  Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
+  
+  arg1 = (Dali::RefObject *)jarg1; 
+  {
+    try {
+      (arg1)->Reference();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
+  Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
+  
+  arg1 = (Dali::RefObject *)jarg1; 
+  {
+    try {
+      (arg1)->Unreference();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
+  int jresult ;
+  Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
+  int result;
+  
+  arg1 = (Dali::RefObject *)jarg1; 
+  {
+    try {
+      result = (int)(arg1)->ReferenceCount();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
+  void * jresult ;
+  Dali::Any *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Any *)new Dali::Any();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
+  Dali::Any *arg1 = (Dali::Any *) 0 ;
+  
+  arg1 = (Dali::Any *)jarg1; 
+  {
+    try {
+      delete arg1;
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
+  char *arg1 = (char *) 0 ;
+  
+  arg1 = (char *)jarg1; 
+  {
+    try {
+      Dali::Any::AssertAlways((char const *)arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
+  void * jresult ;
+  Dali::Any *arg1 = 0 ;
+  Dali::Any *result = 0 ;
+  
+  arg1 = (Dali::Any *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Any *arg1 = (Dali::Any *) 0 ;
+  Dali::Any *arg2 = 0 ;
+  Dali::Any *result = 0 ;
+  
+  arg1 = (Dali::Any *)jarg1; 
+  arg2 = (Dali::Any *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
+  void * jresult ;
+  Dali::Any *arg1 = (Dali::Any *) 0 ;
+  std::type_info *result = 0 ;
+  
+  arg1 = (Dali::Any *)jarg1; 
+  {
+    try {
+      result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
+  unsigned int jresult ;
+  Dali::Any *arg1 = (Dali::Any *) 0 ;
+  bool result;
+  
+  arg1 = (Dali::Any *)jarg1; 
+  {
+    try {
+      result = (bool)((Dali::Any const *)arg1)->Empty();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
+  void * jresult ;
+  std::type_info *arg1 = 0 ;
+  Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
+  Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
+  Dali::Any::AnyContainerBase *result = 0 ;
+  
+  arg1 = (std::type_info *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
+    return 0;
+  } 
+  arg2 = (Dali::Any::CloneFunc)jarg2; 
+  arg3 = (Dali::Any::DeleteFunc)jarg3; 
+  {
+    try {
+      result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
+  void * jresult ;
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  std::type_info *result = 0 ;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  {
+    try {
+      result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
+  void * jresult ;
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  ::std::type_info *result = 0 ;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  arg2 = (Dali::Any::CloneFunc)jarg2; 
+  if (arg1) (arg1)->mCloneFunc = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
+  void * jresult ;
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  Dali::Any::CloneFunc result;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  arg2 = (Dali::Any::DeleteFunc)jarg2; 
+  if (arg1) (arg1)->mDeleteFunc = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
+  void * jresult ;
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  Dali::Any::DeleteFunc result;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
+  Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
+  
+  arg1 = (Dali::Any::AnyContainerBase *)jarg1; 
+  {
+    try {
+      delete arg1;
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
+  Dali::Any *arg1 = (Dali::Any *) 0 ;
+  Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
+  
+  arg1 = (Dali::Any *)jarg1; 
+  arg2 = (Dali::Any::AnyContainerBase *)jarg2; 
+  if (arg1) (arg1)->mContainer = arg2;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
+  void * jresult ;
+  Dali::Any *arg1 = (Dali::Any *) 0 ;
+  Dali::Any::AnyContainerBase *result = 0 ;
+  
+  arg1 = (Dali::Any *)jarg1; 
+  result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Vector2 *)new Dali::Vector2();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
+  void * jresult ;
+  float arg1 ;
+  float arg2 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (float)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
+  void * jresult ;
+  float *arg1 = (float *) 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = jarg1;
+  {
+    try {
+      result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  
+  
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  result = (Dali::Vector2 *)&Dali::Vector2::ONE;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
+  void * jresult ;
+  Dali::Vector2 *result = 0 ;
+  
+  result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float *arg2 = (float *) 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = jarg2;
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  
+  
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  {
+    try {
+      result = ((Dali::Vector2 const *)arg1)->operator -();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  unsigned int arg2 ;
+  float *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (unsigned int)jarg2; 
+  {
+    try {
+      result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = *result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  {
+    try {
+      result = (float)((Dali::Vector2 const *)arg1)->Length();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  {
+    try {
+      result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  {
+    try {
+      (arg1)->Normalize();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 *arg3 = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return ;
+  } 
+  arg3 = (Dali::Vector2 *)jarg3;
+  if (!arg3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return ;
+  } 
+  {
+    try {
+      (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  {
+    try {
+      result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_x_set(void * jarg1, float jarg2) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->x = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_x_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  result = (float) ((arg1)->x);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_width_set(void * jarg1, float jarg2) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->width = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_width_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  result = (float) ((arg1)->width);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_y_set(void * jarg1, float jarg2) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->y = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_y_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  result = (float) ((arg1)->y);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_height_set(void * jarg1, float jarg2) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->height = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_height_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  result = (float) ((arg1)->height);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
+  Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1; 
+  {
+    try {
+      delete arg1;
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = 0 ;
+  float *arg2 = 0 ;
+  float *arg3 = 0 ;
+  float temp2 ;
+  float temp3 ;
+  Dali::Vector2 result;
+  
+  arg1 = (Dali::Vector2 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  temp2 = (float)jarg2; 
+  arg2 = &temp2; 
+  temp3 = (float)jarg3; 
+  arg3 = &temp3; 
+  {
+    try {
+      result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector2((const Dali::Vector2 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Vector3 *)new Dali::Vector3();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
+  void * jresult ;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (float)jarg1; 
+  arg2 = (float)jarg2; 
+  arg3 = (float)jarg3; 
+  {
+    try {
+      result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
+  void * jresult ;
+  float *arg1 = (float *) 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = jarg1;
+  {
+    try {
+      result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  
+  
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::ONE;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
+  void * jresult ;
+  Dali::Vector3 *result = 0 ;
+  
+  result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float *arg2 = (float *) 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = jarg2;
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  
+  
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Quaternion *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Quaternion *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  Dali::Vector3 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->operator -();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  unsigned int arg2 ;
+  float *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (unsigned int)jarg2; 
+  {
+    try {
+      result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = *result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      result = (float)((Dali::Vector3 const *)arg1)->Length();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      (arg1)->Normalize();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 *arg3 = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return ;
+  } 
+  arg3 = (Dali::Vector3 *)jarg3;
+  if (!arg3) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return ;
+  } 
+  {
+    try {
+      (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  Dali::Vector2 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_x_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->x = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_x_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->x);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_width_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->width = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_width_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->width);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->r = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->r);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_y_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->y = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_y_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->y);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_height_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->height = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_height_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->height);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->g = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->g);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_z_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->z = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_z_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->z);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_depth_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->depth = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_depth_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->depth);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float arg2 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  arg2 = (float)jarg2; 
+  if (arg1) (arg1)->b = arg2;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
+  float jresult ;
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  result = (float) ((arg1)->b);
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
+  Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1; 
+  {
+    try {
+      delete arg1;
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; 
+      };
+    }
+  }
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = 0 ;
+  float *arg2 = 0 ;
+  float *arg3 = 0 ;
+  float temp2 ;
+  float temp3 ;
+  Dali::Vector3 result;
+  
+  arg1 = (Dali::Vector3 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  temp2 = (float)jarg2; 
+  arg2 = &temp2; 
+  temp3 = (float)jarg3; 
+  arg3 = &temp3; 
+  {
+    try {
+      result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector3((const Dali::Vector3 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
+  void * jresult ;
+  Dali::Vector4 *result = 0 ;
+  
+  {
+    try {
+      result = (Dali::Vector4 *)new Dali::Vector4();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
+  void * jresult ;
+  float arg1 ;
+  float arg2 ;
+  float arg3 ;
+  float arg4 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (float)jarg1; 
+  arg2 = (float)jarg2; 
+  arg3 = (float)jarg3; 
+  arg4 = (float)jarg4; 
+  {
+    try {
+      result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
+  void * jresult ;
+  float *arg1 = (float *) 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = jarg1;
+  {
+    try {
+      result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  
+  
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
+  void * jresult ;
+  Dali::Vector2 *arg1 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector2 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
+  void * jresult ;
+  Dali::Vector3 *arg1 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector3 *)jarg1;
+  if (!arg1) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
+  void * jresult ;
+  Dali::Vector4 *result = 0 ;
+  
+  result = (Dali::Vector4 *)&Dali::Vector4::ONE;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
+  void * jresult ;
+  Dali::Vector4 *result = 0 ;
+  
+  result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
+  void * jresult ;
+  Dali::Vector4 *result = 0 ;
+  
+  result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
+  void * jresult ;
+  Dali::Vector4 *result = 0 ;
+  
+  result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
+  void * jresult ;
+  Dali::Vector4 *result = 0 ;
+  
+  result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  float *arg2 = (float *) 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = jarg2;
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  
+  
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector2 *arg2 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector2 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  float arg2 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  float arg2 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  float arg2 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  float arg2 ;
+  Dali::Vector4 *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (float)jarg2; 
+  {
+    try {
+      result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = (void *)result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->operator -();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
+  unsigned int jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  bool result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
+  float jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  unsigned int arg2 ;
+  float *result = 0 ;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (unsigned int)jarg2; 
+  {
+    try {
+      result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = *result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
+  float jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector3 *arg2 = 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector3 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
+  float jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
+  float jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = result; 
+  return jresult;
+}
+
+
+SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
+  void * jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  Dali::Vector4 *arg2 = 0 ;
+  Dali::Vector4 result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  arg2 = (Dali::Vector4 *)jarg2;
+  if (!arg2) {
+    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
+    return 0;
+  } 
+  {
+    try {
+      result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0; 
+      };
+    }
+  }
+  jresult = new Dali::Vector4((const Dali::Vector4 &)result); 
+  return jresult;
+}
+
+
+SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
+  float jresult ;
+  Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
+  float result;
+  
+  arg1 = (Dali::Vector4 *)jarg1; 
+  {
+    try {
+      result = (float)((Dali::Vector4 const *)arg1)->Length();
+    } catch (std::out_of_range& e) {
+      {
+        SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (std::exception& e) {
+      {
+        SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0; 
+      };
+    } catch (...) {
+      {
+        SWIG_CSharpException(SWIG_UnknownEr