Name: csapi-nui
Summary: dali-NUI
-Version: 0.2.37
+Version: 0.2.38
Release: 1
Group: Development/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
<None Include="Tizen.NUI.project.json" />\r
</ItemGroup>\r
<ItemGroup>\r
- <Compile Include="Properties\AssemblyInfo.cs" />\r
<Compile Include="src\internal\AccessibilityActionSignal.cs" />\r
<Compile Include="src\internal\AccessibilityFocusOvershotSignal.cs" />\r
<Compile Include="src\internal\AccessibilityManager.cs" />\r
- <Compile Include="src\internal\ActorContainer.cs" />\r
- <Compile Include="src\internal\ActorHoverSignal.cs" />\r
- <Compile Include="src\internal\ActorSignal.cs" />\r
- <Compile Include="src\internal\ActorTouchDataSignal.cs" />\r
- <Compile Include="src\internal\ActorWheelSignal.cs" />\r
<Compile Include="src\internal\Alignment.cs" />\r
<Compile Include="src\internal\AlignType.cs" />\r
<Compile Include="src\internal\AngleAxis.cs" />\r
<Compile Include="src\internal\AngleThresholdPair.cs" />\r
+ <Compile Include="src\internal\Animatable.cs" />\r
<Compile Include="src\internal\AnimatablePropertyComponentRegistration.cs" />\r
<Compile Include="src\internal\AnimatablePropertyRegistration.cs" />\r
<Compile Include="src\internal\AnimationSignal.cs" />\r
<Compile Include="src\internal\BlendModeType.cs" />\r
<Compile Include="src\internal\BufferImage.cs" />\r
<Compile Include="src\internal\Builder.cs" />\r
+ <Compile Include="src\internal\Button.cs" />\r
<Compile Include="src\internal\ButtonSignal.cs" />\r
+ <Compile Include="src\internal\Camera.cs" />\r
<Compile Include="src\internal\ChildPropertyRegistration.cs" />\r
<Compile Include="src\internal\ClampState.cs" />\r
<Compile Include="src\internal\ClampState2D.cs" />\r
<Compile Include="src\internal\EventThreadCallback.cs" />\r
<Compile Include="src\internal\FaceCullingModeType.cs" />\r
<Compile Include="src\internal\FilterModeType.cs" />\r
- <Compile Include="src\internal\FittingModeType.cs" />\r
<Compile Include="src\internal\FixedRuler.cs" />\r
<Compile Include="src\internal\floatp.cs" />\r
<Compile Include="src\internal\FloatSignal.cs" />\r
<Compile Include="src\internal\GaussianBlurViewSignal.cs" />\r
<Compile Include="src\internal\Geometry.cs" />\r
<Compile Include="src\internal\GestureDetector.cs" />\r
- <Compile Include="src\internal\GradientVisualSpreadMethodType.cs" />\r
- <Compile Include="src\internal\GradientVisualUnitsType.cs" />\r
- <Compile Include="src\internal\Handle.cs" />\r
+ <Compile Include="src\internal\HoverSignal.cs" />\r
<Compile Include="src\internal\Image.cs" />\r
<Compile Include="src\internal\ImageSignal.cs" />\r
<Compile Include="src\internal\intp.cs" />\r
<Compile Include="src\internal\ManualPINVOKE.cs" />\r
<Compile Include="src\internal\Matrix.cs" />\r
<Compile Include="src\internal\Matrix3.cs" />\r
- <Compile Include="src\internal\MeshVisualShadingModeValue.cs" />\r
<Compile Include="src\internal\Meta.cs" />\r
<Compile Include="src\internal\Model3dView.cs" />\r
<Compile Include="src\internal\NativeImage.cs" />\r
<Compile Include="src\internal\NDalic.cs" />\r
<Compile Include="src\internal\NDalicPINVOKE.cs" />\r
<Compile Include="src\internal\NinePatchImage.cs" />\r
+ <Compile Include="src\internal\Object.cs" />\r
<Compile Include="src\internal\ObjectCreatedSignal.cs" />\r
<Compile Include="src\internal\ObjectDestroyedSignal.cs" />\r
<Compile Include="src\internal\ObjectRegistry.cs" />\r
<Compile Include="src\internal\PinchGestureDetector.cs" />\r
<Compile Include="src\internal\PixelData.cs" />\r
<Compile Include="src\internal\PixelFormat.cs" />\r
+ <Compile Include="src\internal\Popup.cs" />\r
<Compile Include="src\internal\PositionInheritanceMode.cs" />\r
- <Compile Include="src\internal\PrimitiveVisualShapeType.cs" />\r
+ <Compile Include="src\internal\ProgressBar.cs" />\r
<Compile Include="src\internal\ProgressBarValueChangedSignal.cs" />\r
<Compile Include="src\internal\PropertyBuffer.cs" />\r
<Compile Include="src\internal\PropertyCondition.cs" />\r
<Compile Include="src\internal\PropertyRangeManager.cs" />\r
<Compile Include="src\internal\PropertyRanges.cs" />\r
<Compile Include="src\internal\PropertyRegistration.cs" />\r
+ <Compile Include="src\internal\RadioButton.cs" />\r
<Compile Include="src\internal\RefObject.cs" />\r
<Compile Include="src\internal\RenderBufferFormat.cs" />\r
<Compile Include="src\internal\Renderer.cs" />\r
<Compile Include="src\internal\RulerDomain.cs" />\r
<Compile Include="src\internal\RulerPtr.cs" />\r
<Compile Include="src\internal\Sampler.cs" />\r
- <Compile Include="src\internal\SamplingModeType.cs" />\r
<Compile Include="src\internal\Scrollable.cs" />\r
<Compile Include="src\internal\ScrollableSignal.cs" />\r
<Compile Include="src\internal\ScrollView.cs" />\r
<Compile Include="src\internal\Shader.cs" />\r
<Compile Include="src\internal\SignalConnectorType.cs" />\r
<Compile Include="src\internal\SignalObserver.cs" />\r
+ <Compile Include="src\internal\Size.cs" />\r
+ <Compile Include="src\internal\Slider.cs" />\r
<Compile Include="src\internal\SliderMarkReachedSignal.cs" />\r
<Compile Include="src\internal\SliderValueChangedSignal.cs" />\r
<Compile Include="src\internal\SlotObserver.cs" />\r
<Compile Include="src\internal\ToggleButton.cs" />\r
<Compile Include="src\internal\ToolkitPropertyRange.cs" />\r
<Compile Include="src\internal\TooltipPositionType.cs" />\r
+ <Compile Include="src\internal\TouchDataSignal.cs" />\r
<Compile Include="src\internal\TouchPoint.cs" />\r
<Compile Include="src\internal\TouchPointContainer.cs" />\r
<Compile Include="src\internal\TouchSignal.cs" />\r
<Compile Include="src\internal\VectorUint16Pair.cs" />\r
<Compile Include="src\internal\VectorUnsignedChar.cs" />\r
<Compile Include="src\internal\VideoViewSignal.cs" />\r
+ <Compile Include="src\internal\ViewContainer.cs" />\r
<Compile Include="src\internal\ViewImpl.cs" />\r
<Compile Include="src\internal\ViewMode.cs" />\r
<Compile Include="src\internal\ViewRegistry.cs" />\r
+ <Compile Include="src\internal\ViewResourceReadySignal.cs" />\r
+ <Compile Include="src\internal\ViewSignal.cs" />\r
+ <Compile Include="src\internal\ViewVisibilityChangedSignal.cs" />\r
<Compile Include="src\internal\ViewWrapper.cs" />\r
<Compile Include="src\internal\ViewWrapperImpl.cs" />\r
<Compile Include="src\internal\VisibilityChangeType.cs" />\r
- <Compile Include="src\internal\VisualTransformPolicyType.cs" />\r
- <Compile Include="src\internal\VisualTransformPropertyType.cs" />\r
<Compile Include="src\internal\VisualType.cs" />\r
+ <Compile Include="src\internal\WheelSignal.cs" />\r
<Compile Include="src\internal\WindowFocusSignalType.cs" />\r
<Compile Include="src\internal\VoidSignal.cs" />\r
- <Compile Include="src\internal\WrapModeType.cs" />\r
- <Compile Include="src\public\Actor.cs" />\r
<Compile Include="src\public\AlphaFunction.cs" />\r
<Compile Include="src\public\Animation.cs" />\r
- <Compile Include="src\public\CameraActor.cs" />\r
<Compile Include="src\public\Color.cs" />\r
<Compile Include="src\public\CustomView\Spin.cs" />\r
<Compile Include="src\public\Degree.cs" />\r
<Compile Include="src\public\RelativeVector4.cs" />\r
<Compile Include="src\public\RelayoutContainer.cs" />\r
<Compile Include="src\public\Rotation.cs" />\r
- <Compile Include="src\public\Size.cs" />\r
<Compile Include="src\public\Size2D.cs" />\r
- <Compile Include="src\public\Stage.cs" />\r
<Compile Include="src\public\StyleManager.cs" />\r
<Compile Include="src\public\TableView.cs" />\r
<Compile Include="src\public\TapGesture.cs" />\r
<Compile Include="src\public\BaseComponents\View.cs" />\r
<Compile Include="src\public\BaseComponents\CustomView.cs" />\r
<Compile Include="src\public\BaseComponents\VisualView.cs" />\r
- <Compile Include="src\public\UIComponents\Button.cs" />\r
<Compile Include="src\public\UIComponents\CheckBoxButton.cs" />\r
- <Compile Include="src\public\UIComponents\Popup.cs" />\r
- <Compile Include="src\public\UIComponents\ProgressBar.cs" />\r
<Compile Include="src\public\UIComponents\PushButton.cs" />\r
- <Compile Include="src\public\UIComponents\RadioButton.cs" />\r
<Compile Include="src\public\UIComponents\ScrollBar.cs" />\r
- <Compile Include="src\public\UIComponents\Slider.cs" />\r
<Compile Include="src\public\Vector2.cs" />\r
<Compile Include="src\public\Vector3.cs" />\r
<Compile Include="src\public\Vector4.cs" />\r
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
-internal class AccessibilityFocusOvershotSignal : global::System.IDisposable {
+ using Tizen.NUI.BaseComponents;\r
+ internal class AccessibilityFocusOvershotSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, AccessibilityManager.FocusOvershotDirection arg2) {
- NDalicPINVOKE.AccessibilityFocusOvershotSignal_Emit(swigCPtr, Actor.getCPtr(arg1), (int)arg2);
+ public void Emit(View arg1, AccessibilityManager.FocusOvershotDirection arg2) {
+ NDalicPINVOKE.AccessibilityFocusOvershotSignal_Emit(swigCPtr, View.getCPtr(arg1), (int)arg2);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
using System;
using System.Runtime.InteropServices;
+ using Tizen.NUI.BaseComponents;
internal class AccessibilityManager : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
-
-
-
/**
* @brief Event arguments that passed via StatusChanged signal
*
*/
public class FocusChangedEventArgs : EventArgs
{
- private Actor _actorCurrent;
- private Actor _actorNext;
+ private View _viewCurrent;
+ private View _viewNext;
- public Actor ActorCurrent
- {
+ public View ViewCurrent
+ {
get
{
- return _actorCurrent;
+ return _viewCurrent;
}
set
{
- _actorCurrent = value;
+ _viewCurrent = value;
}
}
- public Actor ActorNext
- {
+ public View ViewNext
+ {
get
{
- return _actorNext;
+ return _viewNext;
}
set
{
- _actorNext = value;
+ _viewNext = value;
}
}
}
/**
- * @brief Event arguments that passed via FocusedActorActivated signal
+ * @brief Event arguments that passed via FocusedViewActivated signal
*
*/
- public class FocusedActorActivatedEventArgs : EventArgs
+ public class FocusedViewActivatedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
- public Actor Actor
- {
+ public View View
+ {
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
}
*/
public class FocusOvershotEventArgs : EventArgs
{
- private Actor _currentFocusedActor;
+ private View _currentFocusedView;
private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
- public Actor CurrentFocusedActor
- {
+ public View CurrentFocusedView
+ {
get
{
- return _currentFocusedActor;
+ return _currentFocusedView;
}
set
{
- _currentFocusedActor = value;
+ _currentFocusedView = value;
}
}
*/
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void FocusChangedEventCallbackDelegate(IntPtr actor1, IntPtr actor2);
+ private delegate void FocusChangedEventCallbackDelegate(IntPtr view1, IntPtr view2);
private DaliEventHandler<object,FocusChangedEventArgs> _accessibilityManagerFocusChangedEventHandler;
private FocusChangedEventCallbackDelegate _accessibilityManagerFocusChangedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void FocusedActorActivatedEventCallbackDelegate(IntPtr actor);
- private DaliEventHandler<object,FocusedActorActivatedEventArgs> _accessibilityManagerFocusedActorActivatedEventHandler;
- private FocusedActorActivatedEventCallbackDelegate _accessibilityManagerFocusedActorActivatedEventCallbackDelegate;
+ private delegate void FocusedViewActivatedEventCallbackDelegate(IntPtr view);
+ private DaliEventHandler<object, FocusedViewActivatedEventArgs> _accessibilityManagerFocusedViewActivatedEventHandler;
+ private FocusedViewActivatedEventCallbackDelegate _accessibilityManagerFocusedViewActivatedEventCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction);
+ private delegate void FocusOvershotEventCallbackDelegate(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction);
private DaliEventHandler<object,FocusOvershotEventArgs> _accessibilityManagerFocusOvershotEventHandler;
private FocusOvershotEventCallbackDelegate _accessibilityManagerFocusOvershotEventCallbackDelegate;
}
// Callback for AccessibilityManager FocusChangedSignal
- private void OnFocusChanged(IntPtr actor1, IntPtr actor2)
+ private void OnFocusChanged(IntPtr view1, IntPtr view2)
{
FocusChangedEventArgs e = new FocusChangedEventArgs();
// Populate all members of "e" (FocusChangedEventArgs) with real data
- e.ActorCurrent = Actor.GetActorFromPtr(actor1);
- e.ActorNext = Actor.GetActorFromPtr(actor2);
+ e.ViewCurrent = View.GetViewFromPtr(view1);
+ e.ViewNext = View.GetViewFromPtr(view2);
if (_accessibilityManagerFocusChangedEventHandler != null)
{
}
}
- public event DaliEventHandler<object,FocusedActorActivatedEventArgs> FocusedActorActivated
+ public event DaliEventHandler<object, FocusedViewActivatedEventArgs> FocusedViewActivated
{
add
{
lock(this)
{
// Restricted to only one listener
- if (_accessibilityManagerFocusedActorActivatedEventHandler == null)
+ if (_accessibilityManagerFocusedViewActivatedEventHandler == null)
{
- _accessibilityManagerFocusedActorActivatedEventHandler += value;
+ _accessibilityManagerFocusedViewActivatedEventHandler += value;
- _accessibilityManagerFocusedActorActivatedEventCallbackDelegate = new FocusedActorActivatedEventCallbackDelegate(OnFocusedActorActivated);
- this.FocusedActorActivatedSignal().Connect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
+ _accessibilityManagerFocusedViewActivatedEventCallbackDelegate = new FocusedViewActivatedEventCallbackDelegate(OnFocusedViewActivated);
+ this.FocusedViewActivatedSignal().Connect(_accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
}
}
}
{
lock(this)
{
- if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
+ if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
{
- this.FocusedActorActivatedSignal().Disconnect(_accessibilityManagerFocusedActorActivatedEventCallbackDelegate);
+ this.FocusedViewActivatedSignal().Disconnect(_accessibilityManagerFocusedViewActivatedEventCallbackDelegate);
}
- _accessibilityManagerFocusedActorActivatedEventHandler -= value;
+ _accessibilityManagerFocusedViewActivatedEventHandler -= value;
}
}
}
- // Callback for AccessibilityManager FocusedActorActivatedSignal
- private void OnFocusedActorActivated(IntPtr actor)
+ // Callback for AccessibilityManager FocusedViewActivatedSignal
+ private void OnFocusedViewActivated(IntPtr view)
{
- FocusedActorActivatedEventArgs e = new FocusedActorActivatedEventArgs();
+ FocusedViewActivatedEventArgs e = new FocusedViewActivatedEventArgs();
- // Populate all members of "e" (FocusedActorActivatedEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ // Populate all members of "e" (FocusedViewActivatedEventArgs) with real data
+ e.View = View.GetViewFromPtr(view);
- if (_accessibilityManagerFocusedActorActivatedEventHandler != null)
+ if (_accessibilityManagerFocusedViewActivatedEventHandler != null)
{
//here we send all data to user event handlers
- _accessibilityManagerFocusedActorActivatedEventHandler(this, e);
+ _accessibilityManagerFocusedViewActivatedEventHandler(this, e);
}
}
}
// Callback for AccessibilityManager FocusOvershotSignal
- private void OnFocusOvershot(IntPtr currentFocusedActor, AccessibilityManager.FocusOvershotDirection direction)
+ private void OnFocusOvershot(IntPtr currentFocusedView, AccessibilityManager.FocusOvershotDirection direction)
{
FocusOvershotEventArgs e = new FocusOvershotEventArgs();
// Populate all members of "e" (FocusOvershotEventArgs) with real data
- e.CurrentFocusedActor = Actor.GetActorFromPtr(currentFocusedActor);
+ e.CurrentFocusedView = View.GetViewFromPtr(currentFocusedView);
e.FocusOvershotDirection = direction;
if (_accessibilityManagerFocusOvershotEventHandler != null)
return ret;
}
-
+
public AccessibilityManager() : this(NDalicPINVOKE.new_AccessibilityManager(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
- public void SetAccessibilityAttribute(Actor actor, AccessibilityManager.AccessibilityAttribute type, string text) {
- NDalicPINVOKE.AccessibilityManager_SetAccessibilityAttribute(swigCPtr, Actor.getCPtr(actor), (int)type, text);
+ public void SetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type, string text) {
+ NDalicPINVOKE.AccessibilityManager_SetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type, text);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public string GetAccessibilityAttribute(Actor actor, AccessibilityManager.AccessibilityAttribute type) {
- string ret = NDalicPINVOKE.AccessibilityManager_GetAccessibilityAttribute(swigCPtr, Actor.getCPtr(actor), (int)type);
+ public string GetAccessibilityAttribute(View view, AccessibilityManager.AccessibilityAttribute type) {
+ string ret = NDalicPINVOKE.AccessibilityManager_GetAccessibilityAttribute(swigCPtr, View.getCPtr(view), (int)type);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void SetFocusOrder(Actor actor, uint order) {
- NDalicPINVOKE.AccessibilityManager_SetFocusOrder(swigCPtr, Actor.getCPtr(actor), order);
+ public void SetFocusOrder(View view, uint order) {
+ NDalicPINVOKE.AccessibilityManager_SetFocusOrder(swigCPtr, View.getCPtr(view), order);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public uint GetFocusOrder(Actor actor) {
- uint ret = NDalicPINVOKE.AccessibilityManager_GetFocusOrder(swigCPtr, Actor.getCPtr(actor));
+ public uint GetFocusOrder(View view) {
+ uint ret = NDalicPINVOKE.AccessibilityManager_GetFocusOrder(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public Actor GetActorByFocusOrder(uint order) {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetActorByFocusOrder(swigCPtr, order), true);
+ public View GetViewByFocusOrder(uint order) {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetActorByFocusOrder(swigCPtr, order), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public bool SetCurrentFocusActor(Actor actor) {
- bool ret = NDalicPINVOKE.AccessibilityManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(actor));
+ public bool SetCurrentFocusView(View view) {
+ bool ret = NDalicPINVOKE.AccessibilityManager_SetCurrentFocusActor(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetCurrentFocusActor() {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusActor(swigCPtr), true);
+ public View GetCurrentFocusView() {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetCurrentFocusGroup() {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusGroup(swigCPtr), true);
+ public View GetCurrentFocusGroup() {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetCurrentFocusGroup(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetFocusGroup(Actor actor, bool isFocusGroup) {
- NDalicPINVOKE.AccessibilityManager_SetFocusGroup(swigCPtr, Actor.getCPtr(actor), isFocusGroup);
+ public void SetFocusGroup(View view, bool isFocusGroup) {
+ NDalicPINVOKE.AccessibilityManager_SetFocusGroup(swigCPtr, View.getCPtr(view), isFocusGroup);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public bool IsFocusGroup(Actor actor) {
- bool ret = NDalicPINVOKE.AccessibilityManager_IsFocusGroup(swigCPtr, Actor.getCPtr(actor));
+ public bool IsFocusGroup(View view) {
+ bool ret = NDalicPINVOKE.AccessibilityManager_IsFocusGroup(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetFocusIndicatorActor(Actor indicator) {
- NDalicPINVOKE.AccessibilityManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
+ public void SetFocusIndicatorView(View indicator) {
+ NDalicPINVOKE.AccessibilityManager_SetFocusIndicatorActor(swigCPtr, View.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetFocusIndicatorActor() {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetFocusIndicatorActor(swigCPtr), true);
+ public View GetFocusIndicatorView() {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetFocusIndicatorActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Actor GetFocusGroup(Actor actor) {
- Actor ret = new Actor(NDalicPINVOKE.AccessibilityManager_GetFocusGroup(swigCPtr, Actor.getCPtr(actor)), true);
+ public View GetFocusGroup(View view) {
+ View ret = new View(NDalicPINVOKE.AccessibilityManager_GetFocusGroup(swigCPtr, View.getCPtr(view)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public ActorSignal FocusedActorActivatedSignal() {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.AccessibilityManager_FocusedActorActivatedSignal(swigCPtr), false);
+ public ViewSignal FocusedViewActivatedSignal() {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.AccessibilityManager_FocusedActorActivatedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Padding() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~AngleThresholdPair() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
* limitations under the License.
*
*/
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-
-public class Handle : BaseHandle {
+
+namespace Tizen.NUI\r
+{
+
+public class Animatable : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- internal Handle(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Handle_SWIGUpcast(cPtr), cMemoryOwn) {
+ internal Animatable(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Handle_SWIGUpcast(cPtr), cMemoryOwn) {
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Handle obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animatable obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
+ ~Animatable() {
+ DisposeQueue.Instance.Add(this);
+ }
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
- public Handle () : this (NDalicPINVOKE.Handle_New(), true) {
+ public Animatable () : this (NDalicPINVOKE.Handle_New(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Handle(Handle handle) : this(NDalicPINVOKE.new_Handle__SWIG_1(Handle.getCPtr(handle)), true) {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- public Handle Assign(Handle rhs) {
- Handle ret = new Handle(NDalicPINVOKE.Handle_Assign(swigCPtr, Handle.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public static Handle DownCast(BaseHandle handle) {
- Handle ret = new Handle(NDalicPINVOKE.Handle_DownCast(BaseHandle.getCPtr(handle)), true);
+ public Animatable(Animatable handle) : this(NDalicPINVOKE.new_Handle__SWIG_1(Animatable.getCPtr(handle)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
}
- public bool Supports(Handle.Capability capability) {
+ public bool Supports(Animatable.Capability capability) {
bool ret = NDalicPINVOKE.Handle_Supports(swigCPtr, (int)capability);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
return ret;
}
- public void SetProperty(int index, PropertyValue propertyValue) {
- NDalicPINVOKE.Handle_SetProperty(swigCPtr, index, PropertyValue.getCPtr(propertyValue));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ public void SetProperty(int index, PropertyValue propertyValue)
+ {
+ Tizen.NUI.Object.SetProperty( swigCPtr, index, propertyValue );
}
public int RegisterProperty(string name, PropertyValue propertyValue) {
return ret;
}
- public PropertyValue GetProperty(int index) {
- PropertyValue ret = new PropertyValue(NDalicPINVOKE.Handle_GetProperty(swigCPtr, index), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ public PropertyValue GetProperty(int index)
+ {
+ PropertyValue ret = Tizen.NUI.Object.GetProperty( swigCPtr, index );
return ret;
}
- internal void GetPropertyIndices(VectorInteger indices)
- {
- NDalicPINVOKE.Handle_GetPropertyIndices(swigCPtr, VectorInteger.getCPtr(indices));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ internal void GetPropertyIndices(VectorInteger indices) {
+ NDalicPINVOKE.Handle_GetPropertyIndices(swigCPtr, VectorInteger.getCPtr(indices));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
- internal PropertyNotification AddPropertyNotification(int index, PropertyCondition condition)
- {
- PropertyNotification ret = new PropertyNotification(NDalicPINVOKE.Handle_AddPropertyNotification__SWIG_0(swigCPtr, index, PropertyCondition.getCPtr(condition)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
+ internal PropertyNotification AddPropertyNotification(int index, PropertyCondition condition) {
+ PropertyNotification ret = new PropertyNotification(NDalicPINVOKE.Handle_AddPropertyNotification__SWIG_0(swigCPtr, index, PropertyCondition.getCPtr(condition)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- internal PropertyNotification AddPropertyNotification(int index, int componentIndex, PropertyCondition condition)
- {
- PropertyNotification ret = new PropertyNotification(NDalicPINVOKE.Handle_AddPropertyNotification__SWIG_1(swigCPtr, index, componentIndex, PropertyCondition.getCPtr(condition)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
+ internal PropertyNotification AddPropertyNotification(int index, int componentIndex, PropertyCondition condition) {
+ PropertyNotification ret = new PropertyNotification(NDalicPINVOKE.Handle_AddPropertyNotification__SWIG_1(swigCPtr, index, componentIndex, PropertyCondition.getCPtr(condition)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- internal void RemovePropertyNotification(PropertyNotification propertyNotification)
- {
- NDalicPINVOKE.Handle_RemovePropertyNotification(swigCPtr, PropertyNotification.getCPtr(propertyNotification));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
+ internal void RemovePropertyNotification(PropertyNotification propertyNotification) {
+ NDalicPINVOKE.Handle_RemovePropertyNotification(swigCPtr, PropertyNotification.getCPtr(propertyNotification));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
public void RemovePropertyNotifications() {
NDalicPINVOKE.Handle_RemovePropertyNotifications(swigCPtr);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~AnyContainerBase() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
{
public const int ver1 = 1;
public const int ver2 = 2;
- public const int ver3 = 37;
+ public const int ver3 = 38;
public const int nuiVer1 = 0;
public const int nuiVer2 = 2;
- public const int nuiVer3 = 37;
+ public const int nuiVer3 = 38;
public const string nuiRelease = "";
}
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
+
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
using System;
using System.Runtime.InteropServices;
+ using Tizen.NUI.BaseComponents;
public class Builder : BaseHandle {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public Animation CreateAnimation(string animationName, Actor sourceActor) {
- Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_2(swigCPtr, animationName, Actor.getCPtr(sourceActor)), true);
+ public Animation CreateAnimation(string animationName, View sourceActor) {
+ Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_2(swigCPtr, animationName, View.getCPtr(sourceActor)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public Animation CreateAnimation(string animationName, PropertyMap map, Actor sourceActor) {
- Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_3(swigCPtr, animationName, PropertyMap.getCPtr(map), Actor.getCPtr(sourceActor)), true);
+ public Animation CreateAnimation(string animationName, PropertyMap map, View sourceActor) {
+ Animation ret = new Animation(NDalicPINVOKE.Builder_CreateAnimation__SWIG_3(swigCPtr, animationName, PropertyMap.getCPtr(map), View.getCPtr(sourceActor)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public bool ApplyStyle(string styleName, Handle handle) {
- bool ret = NDalicPINVOKE.Builder_ApplyStyle(swigCPtr, styleName, Handle.getCPtr(handle));
+ public bool ApplyStyle(string styleName, Animatable handle) {
+ bool ret = NDalicPINVOKE.Builder_ApplyStyle(swigCPtr, styleName, Animatable.getCPtr(handle));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public bool ApplyFromJson(Handle handle, string json) {
- bool ret = NDalicPINVOKE.Builder_ApplyFromJson(swigCPtr, Handle.getCPtr(handle), json);
+ public bool ApplyFromJson(Animatable handle, string json) {
+ bool ret = NDalicPINVOKE.Builder_ApplyFromJson(swigCPtr, Animatable.getCPtr(handle), json);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void AddActors(Actor toActor) {
- NDalicPINVOKE.Builder_AddActors__SWIG_0(swigCPtr, Actor.getCPtr(toActor));
+ public void AddViews(View toActor) {
+ NDalicPINVOKE.Builder_AddActors__SWIG_0(swigCPtr, View.getCPtr(toActor));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void AddActors(string sectionName, Actor toActor) {
- NDalicPINVOKE.Builder_AddActors__SWIG_1(swigCPtr, sectionName, Actor.getCPtr(toActor));
+ public void AddViews(string sectionName, View toActor) {
+ NDalicPINVOKE.Builder_AddActors__SWIG_1(swigCPtr, sectionName, View.getCPtr(toActor));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
return ret;
}
- internal void SetLabel(Actor label)
+ internal void SetLabel(View label)
{
- NDalicPINVOKE.Button_SetLabel(swigCPtr, Actor.getCPtr(label));
+ NDalicPINVOKE.Button_SetLabel(swigCPtr, View.getCPtr(label));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Actor GetButtonImage()
+ internal View GetButtonImage()
{
- Actor ret = new Actor(NDalicPINVOKE.Button_GetButtonImage(swigCPtr), true);
+ View ret = new View(NDalicPINVOKE.Button_GetButtonImage(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- internal Actor GetSelectedImage()
+ internal View GetSelectedImage()
{
- Actor ret = new Actor(NDalicPINVOKE.Button_GetSelectedImage(swigCPtr), true);
+ View ret = new View(NDalicPINVOKE.Button_GetSelectedImage(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
--- /dev/null
+/** Copyright (c) 2017 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.
+*
+*/
+// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.10
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+
+namespace Tizen.NUI {
+
+ public class Camera : Animatable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+
+ internal Camera(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CameraActor_SWIGUpcast(cPtr), cMemoryOwn) {
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Camera obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~Camera() {
+ DisposeQueue.Instance.Add(this);
+ }
+
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_CameraActor(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+
+ public class Property : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~Property() {
+ DisposeQueue.Instance.Add(this);
+ }
+
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_CameraActor_Property(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public Property() : this(NDalicPINVOKE.new_CameraActor_Property(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public static readonly int TYPE = NDalicPINVOKE.CameraActor_Property_TYPE_get();
+ public static readonly int PROJECTION_MODE = NDalicPINVOKE.CameraActor_Property_PROJECTION_MODE_get();
+ public static readonly int FIELD_OF_VIEW = NDalicPINVOKE.CameraActor_Property_FIELD_OF_VIEW_get();
+ public static readonly int ASPECT_RATIO = NDalicPINVOKE.CameraActor_Property_ASPECT_RATIO_get();
+ public static readonly int NEAR_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_NEAR_PLANE_DISTANCE_get();
+ public static readonly int FAR_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_FAR_PLANE_DISTANCE_get();
+ public static readonly int LEFT_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_LEFT_PLANE_DISTANCE_get();
+ public static readonly int RIGHT_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_RIGHT_PLANE_DISTANCE_get();
+ public static readonly int TOP_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_TOP_PLANE_DISTANCE_get();
+ public static readonly int BOTTOM_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_BOTTOM_PLANE_DISTANCE_get();
+ public static readonly int TARGET_POSITION = NDalicPINVOKE.CameraActor_Property_TARGET_POSITION_get();
+ public static readonly int PROJECTION_MATRIX = NDalicPINVOKE.CameraActor_Property_PROJECTION_MATRIX_get();
+ public static readonly int VIEW_MATRIX = NDalicPINVOKE.CameraActor_Property_VIEW_MATRIX_get();
+ public static readonly int INVERT_Y_AXIS = NDalicPINVOKE.CameraActor_Property_INVERT_Y_AXIS_get();
+
+ }
+
+ public Camera () : this (NDalicPINVOKE.CameraActor_New__SWIG_0(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+ public Camera (Vector2 size) : this (NDalicPINVOKE.CameraActor_New__SWIG_1(Vector2.getCPtr(size)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+
+ }
+ public new static Camera DownCast(BaseHandle handle) {
+ Camera ret = new Camera(NDalicPINVOKE.CameraActor_DownCast(BaseHandle.getCPtr(handle)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Camera(Camera copy) : this(NDalicPINVOKE.new_CameraActor__SWIG_1(Camera.getCPtr(copy)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Camera Assign(Camera rhs) {
+ Camera ret = new Camera(NDalicPINVOKE.CameraActor_Assign(swigCPtr, Camera.getCPtr(rhs)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetType(CameraType type) {
+ NDalicPINVOKE.CameraActor_SetType(swigCPtr, (int)type);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public CameraType GetType() {
+ CameraType ret = (CameraType)NDalicPINVOKE.CameraActor_GetType(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetProjectionMode(ProjectionMode mode) {
+ NDalicPINVOKE.CameraActor_SetProjectionMode(swigCPtr, (int)mode);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public ProjectionMode GetProjectionMode() {
+ ProjectionMode ret = (ProjectionMode)NDalicPINVOKE.CameraActor_GetProjectionMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetFieldOfView(float fieldOfView) {
+ NDalicPINVOKE.CameraActor_SetFieldOfView(swigCPtr, fieldOfView);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetFieldOfView() {
+ float ret = NDalicPINVOKE.CameraActor_GetFieldOfView(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetAspectRatio(float aspectRatio) {
+ NDalicPINVOKE.CameraActor_SetAspectRatio(swigCPtr, aspectRatio);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetAspectRatio() {
+ float ret = NDalicPINVOKE.CameraActor_GetAspectRatio(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetNearClippingPlane(float nearClippingPlane) {
+ NDalicPINVOKE.CameraActor_SetNearClippingPlane(swigCPtr, nearClippingPlane);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetNearClippingPlane() {
+ float ret = NDalicPINVOKE.CameraActor_GetNearClippingPlane(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetFarClippingPlane(float farClippingPlane) {
+ NDalicPINVOKE.CameraActor_SetFarClippingPlane(swigCPtr, farClippingPlane);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public float GetFarClippingPlane() {
+ float ret = NDalicPINVOKE.CameraActor_GetFarClippingPlane(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetTargetPosition(Vector3 targetPosition) {
+ NDalicPINVOKE.CameraActor_SetTargetPosition(swigCPtr, Vector3.getCPtr(targetPosition));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Vector3 GetTargetPosition() {
+ Vector3 ret = new Vector3(NDalicPINVOKE.CameraActor_GetTargetPosition(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetInvertYAxis(bool invertYAxis) {
+ NDalicPINVOKE.CameraActor_SetInvertYAxis(swigCPtr, invertYAxis);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public bool GetInvertYAxis() {
+ bool ret = NDalicPINVOKE.CameraActor_GetInvertYAxis(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetPerspectiveProjection(Vector2 size) {
+ NDalicPINVOKE.CameraActor_SetPerspectiveProjection(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetOrthographicProjection(Vector2 size) {
+ NDalicPINVOKE.CameraActor_SetOrthographicProjection__SWIG_0(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void SetOrthographicProjection(float left, float right, float top, float bottom, float near, float far) {
+ NDalicPINVOKE.CameraActor_SetOrthographicProjection__SWIG_1(swigCPtr, left, right, top, bottom, near, far);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public string Type
+ {
+ get
+ {
+ string temp;
+ GetProperty( Camera.Property.TYPE).Get( out temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.TYPE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public string ProjectionMode
+ {
+ get
+ {
+ string temp;
+ GetProperty( Camera.Property.PROJECTION_MODE).Get( out temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.PROJECTION_MODE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float FieldOfView
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.FIELD_OF_VIEW).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.FIELD_OF_VIEW, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float AspectRatio
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.ASPECT_RATIO).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.ASPECT_RATIO, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float NearPlaneDistance
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.NEAR_PLANE_DISTANCE).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.NEAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float FarPlaneDistance
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.FAR_PLANE_DISTANCE).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.FAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float LeftPlaneDistance
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.LEFT_PLANE_DISTANCE).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.LEFT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float RightPlaneDistance
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.RIGHT_PLANE_DISTANCE).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.RIGHT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float TopPlaneDistance
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.TOP_PLANE_DISTANCE).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.TOP_PLANE_DISTANCE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public float BottomPlaneDistance
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty( Camera.Property.BOTTOM_PLANE_DISTANCE).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.BOTTOM_PLANE_DISTANCE, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ public Vector3 TargetPosition
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
+ GetProperty( Camera.Property.TARGET_POSITION).Get( temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.TARGET_POSITION, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+ internal Matrix ProjectionMatrix
+ {
+ get
+ {
+ Matrix temp = new Matrix();
+ GetProperty( Camera.Property.PROJECTION_MATRIX).Get( temp );
+ return temp;
+ }
+} internal Matrix ViewMatrix
+ {
+ get
+ {
+ Matrix temp = new Matrix();
+ GetProperty( Camera.Property.VIEW_MATRIX).Get( temp );
+ return temp;
+ }
+} public bool InvertYAxis
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty( Camera.Property.INVERT_Y_AXIS).Get( ref temp );
+ return temp;
+ }
+ set
+ {
+ SetProperty( Camera.Property.INVERT_Y_AXIS, new Tizen.NUI.PropertyValue( value ) );
+ }
+ }
+
+}
+
+}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Tizen.NUI {
-public class CustomActor : Actor {
+public class CustomActor : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal CustomActor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CustomActor_SWIGUpcast(cPtr), cMemoryOwn) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
- base.Dispose();
}
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
-public class CustomActorImpl : RefObject {
+ using Tizen.NUI.BaseComponents;
+ public class CustomActorImpl : RefObject {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal CustomActorImpl(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CustomActorImpl_SWIGUpcast(cPtr), cMemoryOwn) {
public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnChildAdd(Actor child) {
- NDalicPINVOKE.CustomActorImpl_OnChildAdd(swigCPtr, Actor.getCPtr(child));
+ public virtual void OnChildAdd(View child) {
+ NDalicPINVOKE.CustomActorImpl_OnChildAdd(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnChildRemove(Actor child) {
- NDalicPINVOKE.CustomActorImpl_OnChildRemove(swigCPtr, Actor.getCPtr(child));
+ public virtual void OnChildRemove(View child) {
+ NDalicPINVOKE.CustomActorImpl_OnChildRemove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
- public virtual float CalculateChildSize(Actor child, DimensionType dimension) {
- float ret = NDalicPINVOKE.CustomActorImpl_CalculateChildSize(swigCPtr, Actor.getCPtr(child), (int)dimension);
+ public virtual float CalculateChildSize(View child, DimensionType dimension) {
+ float ret = NDalicPINVOKE.CustomActorImpl_CalculateChildSize(swigCPtr, View.getCPtr(child), (int)dimension);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public virtual Actor GetNextFocusableActor(Actor current, Actor proposed, View.FocusDirection direction) {
- Actor ret = new Actor(NDalicPINVOKE.CustomAlgorithmInterface_GetNextFocusableActor(swigCPtr, Actor.getCPtr(current), Actor.getCPtr(proposed), (int)direction), true);
+ public virtual View GetNextFocusableView(View current, View proposed, View.FocusDirection direction) {
+ View ret = new View(NDalicPINVOKE.CustomAlgorithmInterface_GetNextFocusableActor(swigCPtr, View.getCPtr(current), View.getCPtr(proposed), (int)direction), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
private void SwigDirectorConnect() {
- if (SwigDerivedClassHasMethod("GetNextFocusableActor", swigMethodTypes0))
- swigDelegate0 = new SwigDelegateCustomAlgorithmInterface_0(SwigDirectorGetNextFocusableActor);
+ if (SwigDerivedClassHasMethod("GetNextFocusableView", swigMethodTypes0))
+ swigDelegate0 = new SwigDelegateCustomAlgorithmInterface_0(SwigDirectorGetNextFocusableView);
NDalicPINVOKE.CustomAlgorithmInterface_director_connect(swigCPtr, swigDelegate0);
}
}
#endif
- private global::System.IntPtr SwigDirectorGetNextFocusableActor(global::System.IntPtr current, global::System.IntPtr proposed, int direction) {
- return Actor.getCPtr(GetNextFocusableActor(new Actor(current, true), new Actor(proposed, true), (View.FocusDirection)direction)).Handle;
+ private global::System.IntPtr SwigDirectorGetNextFocusableView(global::System.IntPtr current, global::System.IntPtr proposed, int direction) {
+ return View.getCPtr(GetNextFocusableView(new View(current, true), new View(proposed, true), (View.FocusDirection)direction)).Handle;
}
public delegate global::System.IntPtr SwigDelegateCustomAlgorithmInterface_0(global::System.IntPtr current, global::System.IntPtr proposed, int direction);
private SwigDelegateCustomAlgorithmInterface_0 swigDelegate0;
- private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(Actor), typeof(Actor), typeof(View.FocusDirection) };
+ private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(View), typeof(View), typeof(View.FocusDirection) };
}
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
{
private static readonly DisposeQueue _disposableQueue = new DisposeQueue();
private List<IDisposable> _disposables = new List<IDisposable>();
- private Object _listLock = new object();
+ private System.Object _listLock = new object();
private EventThreadCallback _eventThreadCallback;
private EventThreadCallback.CallbackDelegate _disposeQueueProcessDisposablesDelegate;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* moved to VisualMaps.cs
-public enum FittingModeType {
- SHRINK_TO_FIT,
- SCALE_TO_FILL,
- FIT_WIDTH,
- FIT_HEIGHT
-}
-*/
-}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class FocusChangedSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, Actor arg2) {
- NDalicPINVOKE.FocusChangedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2));
+ public void Emit(View arg1, View arg2) {
+ NDalicPINVOKE.FocusChangedSignal_Emit(swigCPtr, View.getCPtr(arg1), View.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class FocusGroupChangedSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, bool arg2) {
- NDalicPINVOKE.FocusGroupChangedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), arg2);
+ public void Emit(View arg1, bool arg2) {
+ NDalicPINVOKE.FocusGroupChangedSignal_Emit(swigCPtr, View.getCPtr(arg1), arg2);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Attachment() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public new void Add(Actor child) {
- NDalicPINVOKE.GaussianBlurView_Add(swigCPtr, Actor.getCPtr(child));
+ public new void Add(View child) {
+ NDalicPINVOKE.GaussianBlurView_Add(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public new void Remove(Actor child) {
- NDalicPINVOKE.GaussianBlurView_Remove(swigCPtr, Actor.getCPtr(child));
+ public new void Remove(View child) {
+ NDalicPINVOKE.GaussianBlurView_Remove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
-public class GestureDetector : Handle {
+ using Tizen.NUI.BaseComponents;\r
+ public class GestureDetector : BaseHandle {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal GestureDetector(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.GestureDetector_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void Attach(Actor actor) {
- NDalicPINVOKE.GestureDetector_Attach(swigCPtr, Actor.getCPtr(actor));
+ public void Attach(View view) {
+ NDalicPINVOKE.GestureDetector_Attach(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Detach(Actor actor) {
- NDalicPINVOKE.GestureDetector_Detach(swigCPtr, Actor.getCPtr(actor));
+ public void Detach(View view) {
+ NDalicPINVOKE.GestureDetector_Detach(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
- public Actor GetAttachedActor(uint index) {
- Actor ret = new Actor(NDalicPINVOKE.GestureDetector_GetAttachedActor(swigCPtr, index), true);
+ public View GetAttachedActor(uint index) {
+ View ret = new View(NDalicPINVOKE.GestureDetector_GetAttachedActor(swigCPtr, index), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* moved to VisualMaps.cs
- internal enum GradientVisualSpreadMethodType {
- PAD,
- REFLECT,
- REPEAT
-}
-*/
-}
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* moved to VisualMap.cs
- internal enum GradientVisualUnitsType {
- OBJECT_BOUNDING_BOX,
- USER_SPACE
-}
-*/
-}
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// Version 3.0.10
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Tizen.NUI {
+ using Tizen.NUI.BaseComponents;
-internal class ActorHoverSignal : global::System.IDisposable {
+internal class HoverSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorHoverSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal HoverSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorHoverSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(HoverSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorHoverSignal() {
+ ~HoverSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public bool Emit(Actor arg1, Hover arg2) {
- bool ret = NDalicPINVOKE.ActorHoverSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Hover.getCPtr(arg2));
+ public bool Emit(View arg1, Hover arg2) {
+ bool ret = NDalicPINVOKE.ActorHoverSignal_Emit(swigCPtr, View.getCPtr(arg1), Hover.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public ActorHoverSignal() : this(NDalicPINVOKE.new_ActorHoverSignal(), true) {
+ public HoverSignal() : this(NDalicPINVOKE.new_ActorHoverSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
~ImfEventData()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~ImfCallbackData()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~ActivatedSignalType()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~ImfEventSignalType()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~StatusSignalType()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~ImfVoidSignalType()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
public class Item : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Item(uint t, Actor u) : this(NDalicPINVOKE.new_Item__SWIG_1(t, Actor.getCPtr(u)), true) {
+ public Item(uint t, View u) : this(NDalicPINVOKE.new_Item__SWIG_1(t, View.getCPtr(u)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
}
- public Actor second {
+ public View second {
set {
- NDalicPINVOKE.Item_second_set(swigCPtr, Actor.getCPtr(value));
+ NDalicPINVOKE.Item_second_set(swigCPtr, View.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get {
global::System.IntPtr cPtr = NDalicPINVOKE.Item_second_get(swigCPtr);
- Actor ret = (cPtr == global::System.IntPtr.Zero) ? null : new Actor(cPtr, false);
+ View ret = (cPtr == global::System.IntPtr.Zero) ? null : new View(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Tizen.NUI
{
-
+ using Tizen.NUI.BaseComponents;
public class ItemFactory : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
return ret;
}
- public virtual Actor NewItem(uint itemId)
+ public virtual View NewItem(uint itemId)
{
- Actor ret = new Actor(NDalicPINVOKE.ItemFactory_NewItem(swigCPtr, itemId), true);
+ View ret = new View(NDalicPINVOKE.ItemFactory_NewItem(swigCPtr, itemId), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public virtual void ItemReleased(uint itemId, Actor actor)
+ public virtual void ItemReleased(uint itemId, View view)
{
- if (SwigDerivedClassHasMethod("ItemReleased", swigMethodTypes2)) NDalicPINVOKE.ItemFactory_ItemReleasedSwigExplicitItemFactory(swigCPtr, itemId, Actor.getCPtr(actor)); else NDalicPINVOKE.ItemFactory_ItemReleased(swigCPtr, itemId, Actor.getCPtr(actor));
+ if (SwigDerivedClassHasMethod("ItemReleased", swigMethodTypes2)) NDalicPINVOKE.ItemFactory_ItemReleasedSwigExplicitItemFactory(swigCPtr, itemId, View.getCPtr(view)); else NDalicPINVOKE.ItemFactory_ItemReleased(swigCPtr, itemId, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
private global::System.IntPtr SwigDirectorNewItem(uint itemId)
{
- return Actor.getCPtr(NewItem(itemId)).Handle;
+ return View.getCPtr(NewItem(itemId)).Handle;
}
private void SwigDirectorItemReleased(uint itemId, global::System.IntPtr actor)
{
- ItemReleased(itemId, new Actor(actor, true));
+ ItemReleased(itemId, new View(actor, true));
}
public delegate uint SwigDelegateItemFactory_0();
private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes1 = new global::System.Type[] { typeof(uint) };
- private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(uint), typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(uint), typeof(View) };
}
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
return ret;
}
- public virtual void ApplyConstraints(Actor actor, int itemId, Vector3 layoutSize, Actor itemViewActor) {
- NDalicPINVOKE.ItemLayout_ApplyConstraints(swigCPtr, Actor.getCPtr(actor), itemId, Vector3.getCPtr(layoutSize), Actor.getCPtr(itemViewActor));
+ public virtual void ApplyConstraints(View view, int itemId, Vector3 layoutSize, View itemView) {
+ NDalicPINVOKE.ItemLayout_ApplyConstraints(swigCPtr, View.getCPtr(view), itemId, Vector3.getCPtr(layoutSize), View.getCPtr(itemView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetItem(uint itemId) {
- Actor ret = new Actor(NDalicPINVOKE.ItemView_GetItem(swigCPtr, itemId), true);
+ public View GetItem(uint itemId) {
+ View ret = new View(NDalicPINVOKE.ItemView_GetItem(swigCPtr, itemId), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public uint GetItemId(Actor actor) {
- uint ret = NDalicPINVOKE.ItemView_GetItemId(swigCPtr, Actor.getCPtr(actor));
+ public uint GetItemId(View view) {
+ uint ret = NDalicPINVOKE.ItemView_GetItemId(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public Actor Emit(Actor arg1, Actor arg2, View.FocusDirection arg3) {
- Actor ret = new Actor(NDalicManualPINVOKE.PreFocusChangeSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Actor.getCPtr(arg2), (int)arg3), true);
+ public View Emit(View arg1, View arg2, View.FocusDirection arg3) {\r
+ View ret = new View(NDalicManualPINVOKE.PreFocusChangeSignal_Emit(swigCPtr, View.getCPtr(arg1), View.getCPtr(arg2), (int)arg3), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
namespace Tizen.NUI {
- internal class LinearConstrainer : Handle
+ internal class LinearConstrainer : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Remove(Handle target)
+ internal void Remove(Animatable target)
{
- NDalicPINVOKE.LinearConstrainer_Remove(swigCPtr, Handle.getCPtr(target));
+ NDalicPINVOKE.LinearConstrainer_Remove(swigCPtr, Animatable.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- GetProperty(LinearConstrainer.Property.VALUE).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, LinearConstrainer.Property.VALUE).Get(temp);
return temp;
}
set
{
- SetProperty(LinearConstrainer.Property.VALUE, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, LinearConstrainer.Property.VALUE, new Tizen.NUI.PropertyValue(value));
}
}
public PropertyArray Progress
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- GetProperty(LinearConstrainer.Property.PROGRESS).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, LinearConstrainer.Property.PROGRESS).Get(temp);
return temp;
}
set
{
- SetProperty(LinearConstrainer.Property.PROGRESS, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, LinearConstrainer.Property.PROGRESS, new Tizen.NUI.PropertyValue(value));
}
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class LongPressGestureDetectedSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, LongPressGesture arg2) {
- NDalicPINVOKE.LongPressGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), LongPressGesture.getCPtr(arg2));
+ public void Emit(View arg1, LongPressGesture arg2) {
+ NDalicPINVOKE.LongPressGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), LongPressGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
namespace Tizen.NUI {
using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;\r
+using Tizen.NUI.BaseComponents;
public class LongPressGestureDetector : GestureDetector {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private LongPressGesture _longPressGesture;
- public Actor Actor
- {
+ public View View\r
+ {
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (LongPressGestureEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.LongPressGesture = Tizen.NUI.LongPressGesture.GetLongPressGestureFromPtr(longPressGesture);
if (_longPressGestureEventHandler != null)
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* moved to VisualMaps.cs
- internal enum MeshVisualShadingModeValue {
- TEXTURELESS_WITH_DIFFUSE_LIGHTING,
- TEXTURED_WITH_SPECULAR_LIGHTING,
- TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING
-}
-*/
-}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
}
- public static Handle New() {
- Handle ret = new Handle(NDalicPINVOKE.New(), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
public static bool RegisterType(string name, SWIGTYPE_p_std__type_info baseType, System.Delegate f) {
System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(f);
{
return ret;
}
- public static void UnparentAndReset(Actor actor) {
- NDalicPINVOKE.UnparentAndReset(Actor.getCPtr(actor));
+ public static void UnparentAndReset(View view) {
+ NDalicPINVOKE.UnparentAndReset(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void Raise(Actor actor) {
- NDalicPINVOKE.Raise(Actor.getCPtr(actor));
+ public static void Raise(View view) {
+ NDalicPINVOKE.Raise(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void Lower(Actor actor) {
- NDalicPINVOKE.Lower(Actor.getCPtr(actor));
+ public static void Lower(View view) {
+ NDalicPINVOKE.Lower(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void RaiseToTop(Actor actor) {
- NDalicPINVOKE.RaiseToTop(Actor.getCPtr(actor));
+ public static void RaiseToTop(View view) {
+ NDalicPINVOKE.RaiseToTop(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void LowerToBottom(Actor actor) {
- NDalicPINVOKE.LowerToBottom(Actor.getCPtr(actor));
+ public static void LowerToBottom(View view) {
+ NDalicPINVOKE.LowerToBottom(View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void RaiseAbove(Actor actor, Actor target) {
- NDalicPINVOKE.RaiseAbove(Actor.getCPtr(actor), Actor.getCPtr(target));
+ public static void RaiseAbove(View view, View target) {
+ NDalicPINVOKE.RaiseAbove(View.getCPtr(view), View.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static void LowerBelow(Actor actor, Actor target) {
- NDalicPINVOKE.LowerBelow(Actor.getCPtr(actor), Actor.getCPtr(target));
+ public static void LowerBelow(View view, View target) {
+ NDalicPINVOKE.LowerBelow(View.getCPtr(view), View.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static SWIGTYPE_p_Dali__SignalT_void_fDali__Actor_bool_Dali__DevelActor__VisibilityChange__TypeF_t VisibilityChangedSignal(Actor actor) {
- SWIGTYPE_p_Dali__SignalT_void_fDali__Actor_bool_Dali__DevelActor__VisibilityChange__TypeF_t ret = new SWIGTYPE_p_Dali__SignalT_void_fDali__Actor_bool_Dali__DevelActor__VisibilityChange__TypeF_t(NDalicPINVOKE.VisibilityChangedSignal(Actor.getCPtr(actor)), false);
+ public static ViewVisibilityChangedSignal VisibilityChangedSignal(View view) {
+ ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
+ public static KeyInputFocusSignal ResourceReadySignal(View control) {
+ KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.ResourceReadySignal(View.getCPtr(control)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public static bool IsResourceReady(View control) {
+ bool ret = NDalicPINVOKE.IsResourceReady(View.getCPtr(control));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
public static bool IsVertical(ControlOrientationType orientation) {
bool ret = NDalicPINVOKE.IsVertical((int)orientation);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
[global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_delete_ResourceImageSignal")]
public static extern void delete_ResourceImageSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewVisibilityChangedSignal_Empty")]
+ public static extern bool ViewVisibilityChangedSignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount")]
+ public static extern uint ViewVisibilityChangedSignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewVisibilityChangedSignal_Connect")]
+ public static extern void ViewVisibilityChangedSignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewVisibilityChangedSignal_Disconnect")]
+ public static extern void ViewVisibilityChangedSignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewVisibilityChangedSignal_Emit")]
+ public static extern void ViewVisibilityChangedSignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_new_ViewVisibilityChangedSignal")]
+ public static extern global::System.IntPtr new_ViewVisibilityChangedSignal();
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_delete_ViewVisibilityChangedSignal")]
+ public static extern void delete_ViewVisibilityChangedSignal(global::System.Runtime.InteropServices.HandleRef jarg1);
[global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_new_Timer__SWIG_0")]
public static extern global::System.IntPtr new_Timer__SWIG_0();
[global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_new_View__SWIG_2")]
public static extern global::System.IntPtr new_View__SWIG_2(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ResourceReadySignal")]
+ public static extern global::System.IntPtr ResourceReadySignal(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_IsResourceReady")]
+ public static extern bool IsResourceReady(global::System.Runtime.InteropServices.HandleRef jarg1);
[global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_new_KeyInputFocusManager")]
public static extern global::System.IntPtr new_KeyInputFocusManager();
[global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_RulerPtr_ReferenceCount")]
public static extern int RulerPtr_ReferenceCount(global::System.Runtime.InteropServices.HandleRef jarg1);
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewResourceReadySignal_Empty")]
+ public static extern bool ViewResourceReadySignal_Empty(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewResourceReadySignal_GetConnectionCount")]
+ public static extern uint ViewResourceReadySignal_GetConnectionCount(global::System.Runtime.InteropServices.HandleRef jarg1);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewResourceReadySignal_Connect")]
+ public static extern void ViewResourceReadySignal_Connect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewResourceReadySignal_Disconnect")]
+ public static extern void ViewResourceReadySignal_Disconnect(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_ViewResourceReadySignal_Emit")]
+ public static extern void ViewResourceReadySignal_Emit(global::System.Runtime.InteropServices.HandleRef jarg1, global::System.Runtime.InteropServices.HandleRef jarg2);
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_new_ViewResourceReadySignal")]
+ public static extern global::System.IntPtr new_ViewResourceReadySignal();
+
+ [global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_delete_ViewResourceReadySignal")]
+ public static extern void delete_ViewResourceReadySignal(global::System.Runtime.InteropServices.HandleRef jarg1);
[global::System.Runtime.InteropServices.DllImport("libdali-csharp-binder.so", EntryPoint="CSharp_Dali_BaseObject_SWIGUpcast")]
public static extern global::System.IntPtr BaseObject_SWIGUpcast(global::System.IntPtr jarg1);
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
--- /dev/null
+/** Copyright (c) 2017 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.
+*
+*/
+
+/**
+ * Static Helper class for Property
+ * Internal
+ */
+
+namespace Tizen.NUI
+{
+
+public static class Object
+{
+ public static PropertyValue GetProperty(global::System.Runtime.InteropServices.HandleRef handle, int index) {
+ PropertyValue ret = new PropertyValue(NDalicPINVOKE.Handle_GetProperty(handle, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public static void SetProperty( global::System.Runtime.InteropServices.HandleRef handle, int index, PropertyValue propertyValue)
+ {
+ NDalicPINVOKE.Handle_SetProperty(handle, index, PropertyValue.getCPtr(propertyValue));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+}
+
+}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class PanGestureDetectedSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, PanGesture arg2) {
- NDalicPINVOKE.PanGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), PanGesture.getCPtr(arg2));
+ public void Emit(View arg1, PanGesture arg2) {
+ NDalicPINVOKE.PanGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), PanGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
namespace Tizen.NUI {
using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;\r
+ using Tizen.NUI.BaseComponents;
public class PanGestureDetector : GestureDetector {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private PanGesture _panGesture;
- public Actor Actor
- {
+ public View View\r
+ {
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (PanGestureEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.PanGesture = Tizen.NUI.PanGesture.GetPanGestureFromPtr(panGesture);
if (_panGestureEventHandler != null)
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.SCREEN_POSITION).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.SCREEN_POSITION).Get( temp );
return temp;
}
} public Vector2 ScreenDisplacement
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.SCREEN_DISPLACEMENT).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.SCREEN_DISPLACEMENT).Get( temp );
return temp;
}
} public Vector2 ScreenVelocity
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.SCREEN_VELOCITY).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.SCREEN_VELOCITY).Get( temp );
return temp;
}
} public Vector2 LocalPosition
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.LOCAL_POSITION).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.LOCAL_POSITION).Get( temp );
return temp;
}
} public Vector2 LocalDisplacement
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.LOCAL_DISPLACEMENT).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.LOCAL_DISPLACEMENT).Get( temp );
return temp;
}
} public Vector2 LocalVelocity
get
{
Vector2 temp = new Vector2(0.0f,0.0f);
- GetProperty( PanGestureDetector.Property.LOCAL_VELOCITY).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.LOCAL_VELOCITY).Get( temp );
return temp;
}
} public bool Panning
get
{
bool temp = false;
- GetProperty( PanGestureDetector.Property.PANNING).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.PANNING).Get( ref temp );
return temp;
}
}
namespace Tizen.NUI {
- internal class PathConstrainer : Handle
+ internal class PathConstrainer : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Remove(Handle target)
+ internal void Remove(Animatable target)
{
- NDalicPINVOKE.PathConstrainer_Remove(swigCPtr, Handle.getCPtr(target));
+ NDalicPINVOKE.PathConstrainer_Remove(swigCPtr, Animatable.getCPtr(target));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
- GetProperty(PathConstrainer.Property.FORWARD).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, PathConstrainer.Property.FORWARD).Get(temp);
return temp;
}
set
{
- SetProperty(PathConstrainer.Property.FORWARD, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, PathConstrainer.Property.FORWARD, new Tizen.NUI.PropertyValue(value));
}
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- GetProperty(PathConstrainer.Property.POINTS).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, PathConstrainer.Property.POINTS).Get(temp);
return temp;
}
set
{
- SetProperty(PathConstrainer.Property.POINTS, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, PathConstrainer.Property.POINTS, new Tizen.NUI.PropertyValue(value));
}
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- GetProperty(PathConstrainer.Property.CONTROL_POINTS).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, PathConstrainer.Property.CONTROL_POINTS).Get(temp);
return temp;
}
set
{
- SetProperty(PathConstrainer.Property.CONTROL_POINTS, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, PathConstrainer.Property.CONTROL_POINTS, new Tizen.NUI.PropertyValue(value));
}
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class PinchGestureDetectedSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, PinchGesture arg2) {
- NDalicPINVOKE.PinchGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), PinchGesture.getCPtr(arg2));
+ public void Emit(View arg1, PinchGesture arg2) {
+ NDalicPINVOKE.PinchGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), PinchGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
using System;
using System.Runtime.InteropServices;
+ using Tizen.NUI.BaseComponents;
public class PinchGestureDetector : GestureDetector {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private PinchGesture _pinchGesture;
- public Actor Actor
- {
+ public View View\r
+ {
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (DetectedEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.PinchGesture = Tizen.NUI.PinchGesture.GetPinchGestureFromPtr(pinchGesture);
if (_pinchGestureEventHandler != null)
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// Sets a title for this Popup.
/// </summary>
/// <param name="titleActor">The actor to set a title</param>
- public void SetTitle(Actor titleActor)
+ public void SetTitle(View titleView)
{
- NDalicPINVOKE.Popup_SetTitle(swigCPtr, Actor.getCPtr(titleActor));
+ NDalicPINVOKE.Popup_SetTitle(swigCPtr, View.getCPtr(titleView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Actor GetTitle()
+ internal View GetTitle()
{
- Actor ret = new Actor(NDalicPINVOKE.Popup_GetTitle(swigCPtr), true);
+ View ret = new View(NDalicPINVOKE.Popup_GetTitle(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// Sets the content actor.
/// </summary>
/// <param name="content">The actor to use</param>
- public void SetContent(Actor content)
+ public void SetContent(View content)
{
- NDalicPINVOKE.Popup_SetContent(swigCPtr, Actor.getCPtr(content));
+ NDalicPINVOKE.Popup_SetContent(swigCPtr, View.getCPtr(content));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Actor GetContent()
+ internal View GetContent()
{
- Actor ret = new Actor(NDalicPINVOKE.Popup_GetContent(swigCPtr), true);
+ View ret = new View(NDalicPINVOKE.Popup_GetContent(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// Sets the actor to use for a footer in this Popup.
/// </summary>
/// <param name="footer">The footer actor to be added to this Popup</param>
- public void SetFooter(Actor footer)
+ public void SetFooter(View footer)
{
- NDalicPINVOKE.Popup_SetFooter(swigCPtr, Actor.getCPtr(footer));
+ NDalicPINVOKE.Popup_SetFooter(swigCPtr, View.getCPtr(footer));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Actor GetFooter()
+ internal View GetFooter()
{
- Actor ret = new Actor(NDalicPINVOKE.Popup_GetFooter(swigCPtr), true);
+ View ret = new View(NDalicPINVOKE.Popup_GetFooter(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* moved to VisualMaps.cs
- internal enum PrimitiveVisualShapeType {
- SPHERE,
- CONICAL_FRUSTRUM,
- CONE,
- CYLINDER,
- CUBE,
- OCTAHEDRON,
- BEVELLED_CUBE
-}
-*/
-}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public Handle GetTarget() {
- Handle ret = new Handle(NDalicPINVOKE.PropertyNotification_GetTarget(swigCPtr), true);
+ public Animatable GetTarget() {
+ Animatable ret = new Animatable(NDalicPINVOKE.PropertyNotification_GetTarget(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
- internal class RenderTask : Handle {
+ using Tizen.NUI.BaseComponents;
+ internal class RenderTask : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal RenderTask(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.RenderTask_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
return ret;
}
- public void SetSourceActor(Actor actor) {
- NDalicPINVOKE.RenderTask_SetSourceActor(swigCPtr, Actor.getCPtr(actor));
+ public void SetSourceView(View view) {
+ NDalicPINVOKE.RenderTask_SetSourceActor(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetSourceActor() {
- Actor ret = new Actor(NDalicPINVOKE.RenderTask_GetSourceActor(swigCPtr), true);
+ public View GetSourceView() {
+ View ret = new View(NDalicPINVOKE.RenderTask_GetSourceActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetCameraActor(CameraActor cameraActor) {
- NDalicPINVOKE.RenderTask_SetCameraActor(swigCPtr, CameraActor.getCPtr(cameraActor));
+ public void SetCamera(Camera camera) {
+ NDalicPINVOKE.RenderTask_SetCameraActor(swigCPtr, Camera.getCPtr(camera));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public CameraActor GetCameraActor() {
- CameraActor ret = new CameraActor(NDalicPINVOKE.RenderTask_GetCameraActor(swigCPtr), true);
+ public Camera GetCamera() {
+ Camera ret = new Camera(NDalicPINVOKE.RenderTask_GetCameraActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public void SetScreenToFrameBufferMappingActor(Actor mappingActor) {
- NDalicPINVOKE.RenderTask_SetScreenToFrameBufferMappingActor(swigCPtr, Actor.getCPtr(mappingActor));
+ public void SetScreenToFrameBufferMappingView(View mappingView) {
+ NDalicPINVOKE.RenderTask_SetScreenToFrameBufferMappingActor(swigCPtr, View.getCPtr(mappingView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public Actor GetScreenToFrameBufferMappingActor() {
- Actor ret = new Actor(NDalicPINVOKE.RenderTask_GetScreenToFrameBufferMappingActor(swigCPtr), true);
+ public View GetScreenToFrameBufferMappingView() {
+ View ret = new View(NDalicPINVOKE.RenderTask_GetScreenToFrameBufferMappingActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
- public bool ViewportToLocal(Actor actor, float viewportX, float viewportY, out float localX, out float localY) {
- bool ret = NDalicPINVOKE.RenderTask_ViewportToLocal(swigCPtr, Actor.getCPtr(actor), viewportX, viewportY, out localX, out localY);
+ public bool ViewportToLocal(View view, float viewportX, float viewportY, out float localX, out float localY) {
+ bool ret = NDalicPINVOKE.RenderTask_ViewportToLocal(swigCPtr, View.getCPtr(view), viewportX, viewportY, out localX, out localY);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Tizen.NUI {
- internal class Renderer : Handle {
+ internal class Renderer : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Renderer(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Renderer_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
global::System.GC.SuppressFinalize(this);
base.Dispose();
}
- }
-
-
- public class Property : global::System.IDisposable {
+ }\r
+ public class Property : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_INDEX).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.DEPTH_INDEX).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_INDEX, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.DEPTH_INDEX, new Tizen.NUI.PropertyValue( value ) );
}
}
public int FaceCullingMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.FACE_CULLING_MODE).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.FACE_CULLING_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.FACE_CULLING_MODE, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.FACE_CULLING_MODE, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_MODE).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_MODE, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_MODE, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendEquationRgb
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_EQUATION_RGB).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_EQUATION_RGB).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_EQUATION_RGB, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_EQUATION_RGB, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendEquationAlpha
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_EQUATION_ALPHA).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_EQUATION_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_EQUATION_ALPHA, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_EQUATION_ALPHA, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendFactorSrcRgb
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_SRC_RGB).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_RGB).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_SRC_RGB, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_RGB, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendFactorDestRgb
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_DEST_RGB).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_RGB).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_DEST_RGB, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_RGB, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendFactorSrcAlpha
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_SRC_ALPHA).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_SRC_ALPHA, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_SRC_ALPHA, new Tizen.NUI.PropertyValue( value ) );
}
}
public int BlendFactorDestAlpha
get
{
int temp = 0;
- GetProperty( Renderer.Property.BLEND_FACTOR_DEST_ALPHA).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_FACTOR_DEST_ALPHA, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_FACTOR_DEST_ALPHA, new Tizen.NUI.PropertyValue( value ) );
}
}
public Vector4 BlendColor
get
{
Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
- GetProperty( Renderer.Property.BLEND_COLOR).Get( temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_COLOR).Get( temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_COLOR, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_COLOR, new Tizen.NUI.PropertyValue( value ) );
}
}
public bool BlendPreMultipliedAlpha
get
{
bool temp = false;
- GetProperty( Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.BLEND_PRE_MULTIPLIED_ALPHA, new Tizen.NUI.PropertyValue( value ) );
}
}
public int IndexRangeFirst
get
{
int temp = 0;
- GetProperty( Renderer.Property.INDEX_RANGE_FIRST).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.INDEX_RANGE_FIRST).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.INDEX_RANGE_FIRST, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.INDEX_RANGE_FIRST, new Tizen.NUI.PropertyValue( value ) );
}
}
public int IndexRangeCount
get
{
int temp = 0;
- GetProperty( Renderer.Property.INDEX_RANGE_COUNT).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.INDEX_RANGE_COUNT).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.INDEX_RANGE_COUNT, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.INDEX_RANGE_COUNT, new Tizen.NUI.PropertyValue( value ) );
}
}
public int DepthWriteMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_WRITE_MODE).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.DEPTH_WRITE_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_WRITE_MODE, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.DEPTH_WRITE_MODE, new Tizen.NUI.PropertyValue( value ) );
}
}
public int DepthFunction
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_FUNCTION).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.DEPTH_FUNCTION).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_FUNCTION, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.DEPTH_FUNCTION, new Tizen.NUI.PropertyValue( value ) );
}
}
public int DepthTestMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.DEPTH_TEST_MODE).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.DEPTH_TEST_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.DEPTH_TEST_MODE, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.DEPTH_TEST_MODE, new Tizen.NUI.PropertyValue( value ) );
}
}
public int RenderMode
get
{
int temp = 0;
- GetProperty( Renderer.Property.RENDER_MODE).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.RENDER_MODE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.RENDER_MODE, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.RENDER_MODE, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilFunction
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_FUNCTION).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_FUNCTION).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_FUNCTION, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_FUNCTION, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilFunctionMask
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_FUNCTION_MASK).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_FUNCTION_MASK).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_FUNCTION_MASK, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_FUNCTION_MASK, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilFunctionReference
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_FUNCTION_REFERENCE).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_FUNCTION_REFERENCE).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_FUNCTION_REFERENCE, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_FUNCTION_REFERENCE, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilMask
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_MASK).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_MASK).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_MASK, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_MASK, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilOperationOnFail
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_OPERATION_ON_FAIL).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_FAIL).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_OPERATION_ON_FAIL, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_FAIL, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilOperationOnZFail
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_FAIL, new Tizen.NUI.PropertyValue( value ) );
}
}
public int StencilOperationOnZPass
get
{
int temp = 0;
- GetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_PASS).Get( ref temp );
+ Tizen.NUI.Object.GetProperty(swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_PASS).Get( ref temp );
return temp;
}
set
{
- SetProperty( Renderer.Property.STENCIL_OPERATION_ON_Z_PASS, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Renderer.Property.STENCIL_OPERATION_ON_Z_PASS, new Tizen.NUI.PropertyValue( value ) );
}
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
- DisposeQueue.Instance.Add(this);
- return;
- }
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* moved to VisualMaps.cs
-public enum SamplingModeType {
- BOX,
- NEAREST,
- LINEAR,
- BOX_THEN_NEAREST,
- BOX_THEN_LINEAR,
- NO_FILTER,
- DONT_CARE
-}
-*/
-}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~ClampEvent() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
~SnapEvent() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetActorAutoSnap(bool enable) {
+ public void SetViewAutoSnap(bool enable) {
NDalicPINVOKE.ScrollView_SetActorAutoSnap(swigCPtr, enable);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void ScrollTo(Actor actor) {
- NDalicPINVOKE.ScrollView_ScrollTo__SWIG_8(swigCPtr, Actor.getCPtr(actor));
+ public void ScrollTo(View view) {
+ NDalicPINVOKE.ScrollView_ScrollTo__SWIG_8(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void ScrollTo(Actor actor, float duration) {
- NDalicPINVOKE.ScrollView_ScrollTo__SWIG_9(swigCPtr, Actor.getCPtr(actor), duration);
+ public void ScrollTo(View view, float duration) {
+ NDalicPINVOKE.ScrollView_ScrollTo__SWIG_9(swigCPtr, View.getCPtr(view), duration);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void BindActor(Actor child) {
- NDalicPINVOKE.ScrollView_BindActor(swigCPtr, Actor.getCPtr(child));
+ public void BindView(View child) {
+ NDalicPINVOKE.ScrollView_BindActor(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void UnbindActor(Actor child) {
- NDalicPINVOKE.ScrollView_UnbindActor(swigCPtr, Actor.getCPtr(child));
+ public void UnbindView(View child) {
+ NDalicPINVOKE.ScrollView_UnbindActor(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class ScrollViewPagePathEffect : ScrollViewEffect {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
return ret;
}
- public void ApplyToPage(Actor page, uint pageOrder) {
- NDalicPINVOKE.ScrollViewPagePathEffect_ApplyToPage(swigCPtr, Actor.getCPtr(page), pageOrder);
+ public void ApplyToPage(View page, uint pageOrder) {
+ NDalicPINVOKE.ScrollViewPagePathEffect_ApplyToPage(swigCPtr, View.getCPtr(page), pageOrder);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
namespace Tizen.NUI {
- internal class Shader : Handle {
+ internal class Shader : Animatable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Shader(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Shader_SWIGUpcast(cPtr), cMemoryOwn) {
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Hint() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
{
get
{
- Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
- GetProperty( Shader.Property.PROGRAM).Get( temp );
+ Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();\r
+ Tizen.NUI.Object.GetProperty(swigCPtr, Shader.Property.PROGRAM).Get( temp );
return temp;
}
set
{
- SetProperty( Shader.Property.PROGRAM, new Tizen.NUI.PropertyValue( value ) );
+ Tizen.NUI.Object.SetProperty(swigCPtr, Shader.Property.PROGRAM, new Tizen.NUI.PropertyValue( value ) );
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
/// </summary>
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
+ using Tizen.NUI.BaseComponents;
internal class TapGestureDetectedSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg1, TapGesture arg2) {
- NDalicPINVOKE.TapGestureDetectedSignal_Emit(swigCPtr, Actor.getCPtr(arg1), TapGesture.getCPtr(arg2));
+ public void Emit(View arg1, TapGesture arg2) {
+ NDalicPINVOKE.TapGestureDetectedSignal_Emit(swigCPtr, View.getCPtr(arg1), TapGesture.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
namespace Tizen.NUI {
using System;
-using System.Runtime.InteropServices;
+using System.Runtime.InteropServices;\r
+ using Tizen.NUI.BaseComponents;
public class TapGestureDetector : GestureDetector {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public class DetectedEventArgs : EventArgs
{
- private Actor _actor;
+ private View _view;
private TapGesture _tapGesture;
- public Actor Actor
- {
+ public View View\r
+ {
get
{
- return _actor;
+ return _view;
}
set
{
- _actor = value;
+ _view = value;
}
}
DetectedEventArgs e = new DetectedEventArgs();
// Populate all members of "e" (DetectedEventArgs) with real data
- e.Actor = Actor.GetActorFromPtr(actor);
+ e.View = View.GetViewFromPtr(actor);
e.TapGesture = Tizen.NUI.TapGesture.GetTapGestureFromPtr(tapGesture);
if (_tapGestureEventHandler != null)
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
~Property() {
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock(this) {
if (swigCPtr.Handle != global::System.IntPtr.Zero) {
if (swigCMemOwn) {
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// Version 3.0.10
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
- internal class ActorTouchDataSignal : global::System.IDisposable {
+ using Tizen.NUI.BaseComponents;
+internal class TouchDataSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorTouchDataSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal TouchDataSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorTouchDataSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(TouchDataSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorTouchDataSignal() {
+ ~TouchDataSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public bool Emit(Actor arg1, Touch arg2) {
- bool ret = NDalicPINVOKE.ActorTouchDataSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Touch.getCPtr(arg2));
+ public bool Emit(View arg1, Touch arg2) {
+ bool ret = NDalicPINVOKE.ActorTouchDataSignal_Emit(swigCPtr, View.getCPtr(arg1), Touch.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public ActorTouchDataSignal() : this(NDalicPINVOKE.new_ActorTouchDataSignal(), true) {
+ public TouchDataSignal() : this(NDalicPINVOKE.new_ActorTouchDataSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
namespace Tizen.NUI {
+ using Tizen.NUI.BaseComponents;
internal class TouchPoint : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public Actor hitActor {
+ public View hitView {
set {
- NDalicPINVOKE.TouchPoint_hitActor_set(swigCPtr, Actor.getCPtr(value));
+ NDalicPINVOKE.TouchPoint_hitActor_set(swigCPtr, View.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get {
global::System.IntPtr cPtr = NDalicPINVOKE.TouchPoint_hitActor_get(swigCPtr);
- Actor ret = (cPtr == global::System.IntPtr.Zero) ? null : new Actor(cPtr, false);
+ View ret = (cPtr == global::System.IntPtr.Zero) ? null : new View(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public override void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// Version 3.0.10
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Tizen.NUI {
+ using Tizen.NUI.BaseComponents;
-internal class ActorContainer : global::System.IDisposable, global::System.Collections.IEnumerable
- , global::System.Collections.Generic.IEnumerable<Actor>
+public class ViewContainer : global::System.IDisposable, global::System.Collections.IEnumerable
+ , global::System.Collections.Generic.IEnumerable<View>
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorContainer(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal ViewContainer(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorContainer obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewContainer obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorContainer() {
+ ~ViewContainer() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
- public ActorContainer(global::System.Collections.ICollection c) : this() {
+ public ViewContainer(global::System.Collections.ICollection c) : this() {
if (c == null)
throw new global::System.ArgumentNullException("c");
- foreach (Actor element in c) {
+ foreach (View element in c) {
this.Add(element);
}
}
}
}
- public Actor this[int index] {
+ public View this[int index] {
get {
return getitem(index);
}
}
}
- public void CopyTo(Actor[] array)
+ public void CopyTo(View[] array)
{
CopyTo(0, array, 0, this.Count);
}
- public void CopyTo(Actor[] array, int arrayIndex)
+ public void CopyTo(View[] array, int arrayIndex)
{
CopyTo(0, array, arrayIndex, this.Count);
}
- public void CopyTo(int index, Actor[] array, int arrayIndex, int count)
+ public void CopyTo(int index, View[] array, int arrayIndex, int count)
{
if (array == null)
throw new global::System.ArgumentNullException("array");
array.SetValue(getitemcopy(index+i), arrayIndex+i);
}
- global::System.Collections.Generic.IEnumerator<Actor> global::System.Collections.Generic.IEnumerable<Actor>.GetEnumerator() {
- return new ActorContainerEnumerator(this);
+ global::System.Collections.Generic.IEnumerator<View> global::System.Collections.Generic.IEnumerable<View>.GetEnumerator() {
+ return new ViewContainerEnumerator(this);
}
global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator() {
- return new ActorContainerEnumerator(this);
+ return new ViewContainerEnumerator(this);
}
- public ActorContainerEnumerator GetEnumerator() {
- return new ActorContainerEnumerator(this);
+ public ViewContainerEnumerator GetEnumerator() {
+ return new ViewContainerEnumerator(this);
}
// Type-safe enumerator
/// whenever the collection is modified. This has been done for changes in the size of the
/// collection but not when one of the elements of the collection is modified as it is a bit
/// tricky to detect unmanaged code that modifies the collection under our feet.
- public sealed class ActorContainerEnumerator : global::System.Collections.IEnumerator
- , global::System.Collections.Generic.IEnumerator<Actor>
+ public sealed class ViewContainerEnumerator : global::System.Collections.IEnumerator
+ , global::System.Collections.Generic.IEnumerator<View>
{
- private ActorContainer collectionRef;
+ private ViewContainer collectionRef;
private int currentIndex;
private object currentObject;
private int currentSize;
- public ActorContainerEnumerator(ActorContainer collection) {
+ public ViewContainerEnumerator(ViewContainer collection) {
collectionRef = collection;
currentIndex = -1;
currentObject = null;
}
// Type-safe iterator Current
- public Actor Current {
+ public View Current {
get {
if (currentIndex == -1)
throw new global::System.InvalidOperationException("Enumeration not started.");
throw new global::System.InvalidOperationException("Enumeration finished.");
if (currentObject == null)
throw new global::System.InvalidOperationException("Collection modified.");
- return (Actor)currentObject;
+ return (View)currentObject;
}
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void Add(Actor x) {
- NDalicPINVOKE.ActorContainer_Add(swigCPtr, Actor.getCPtr(x));
+ public void Add(View x) {
+ NDalicPINVOKE.ActorContainer_Add(swigCPtr, View.getCPtr(x));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer() : this(NDalicPINVOKE.new_ActorContainer__SWIG_0(), true) {
+ public ViewContainer() : this(NDalicPINVOKE.new_ActorContainer__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer(ActorContainer other) : this(NDalicPINVOKE.new_ActorContainer__SWIG_1(ActorContainer.getCPtr(other)), true) {
+ public ViewContainer(ViewContainer other) : this(NDalicPINVOKE.new_ActorContainer__SWIG_1(ViewContainer.getCPtr(other)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer(int capacity) : this(NDalicPINVOKE.new_ActorContainer__SWIG_2(capacity), true) {
+ public ViewContainer(int capacity) : this(NDalicPINVOKE.new_ActorContainer__SWIG_2(capacity), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- private Actor getitemcopy(int index) {
- Actor ret = new Actor(NDalicPINVOKE.ActorContainer_getitemcopy(swigCPtr, index), true);
+ private View getitemcopy(int index) {
+ View ret = new View(NDalicPINVOKE.ActorContainer_getitemcopy(swigCPtr, index), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- private Actor getitem(int index) {
- Actor ret = new Actor(NDalicPINVOKE.ActorContainer_getitem(swigCPtr, index), false);
+ private View getitem(int index) {
+ View ret = new View(NDalicPINVOKE.ActorContainer_getitem(swigCPtr, index), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- private void setitem(int index, Actor val) {
- NDalicPINVOKE.ActorContainer_setitem(swigCPtr, index, Actor.getCPtr(val));
+ private void setitem(int index, View val) {
+ NDalicPINVOKE.ActorContainer_setitem(swigCPtr, index, View.getCPtr(val));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void AddRange(ActorContainer values) {
- NDalicPINVOKE.ActorContainer_AddRange(swigCPtr, ActorContainer.getCPtr(values));
+ public void AddRange(ViewContainer values) {
+ NDalicPINVOKE.ActorContainer_AddRange(swigCPtr, ViewContainer.getCPtr(values));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorContainer GetRange(int index, int count) {
+ public ViewContainer GetRange(int index, int count) {
global::System.IntPtr cPtr = NDalicPINVOKE.ActorContainer_GetRange(swigCPtr, index, count);
- ActorContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ActorContainer(cPtr, true);
+ ViewContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ViewContainer(cPtr, true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public void Insert(int index, Actor x) {
- NDalicPINVOKE.ActorContainer_Insert(swigCPtr, index, Actor.getCPtr(x));
+ public void Insert(int index, View x) {
+ NDalicPINVOKE.ActorContainer_Insert(swigCPtr, index, View.getCPtr(x));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void InsertRange(int index, ActorContainer values) {
- NDalicPINVOKE.ActorContainer_InsertRange(swigCPtr, index, ActorContainer.getCPtr(values));
+ public void InsertRange(int index, ViewContainer values) {
+ NDalicPINVOKE.ActorContainer_InsertRange(swigCPtr, index, ViewContainer.getCPtr(values));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public static ActorContainer Repeat(Actor value, int count) {
- global::System.IntPtr cPtr = NDalicPINVOKE.ActorContainer_Repeat(Actor.getCPtr(value), count);
- ActorContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ActorContainer(cPtr, true);
+ public static ViewContainer Repeat(View value, int count) {
+ global::System.IntPtr cPtr = NDalicPINVOKE.ActorContainer_Repeat(View.getCPtr(value), count);
+ ViewContainer ret = (cPtr == global::System.IntPtr.Zero) ? null : new ViewContainer(cPtr, true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public void SetRange(int index, ActorContainer values) {
- NDalicPINVOKE.ActorContainer_SetRange(swigCPtr, index, ActorContainer.getCPtr(values));
+ public void SetRange(int index, ViewContainer values) {
+ NDalicPINVOKE.ActorContainer_SetRange(swigCPtr, index, ViewContainer.getCPtr(values));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- protected virtual new void OnChildAdd(Actor child)
+ protected virtual new void OnChildAdd(View child)
{
- if (SwigDerivedClassHasMethod("OnChildAdd", swigMethodTypes2)) NDalicPINVOKE.ViewImpl_OnChildAddSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildAdd(swigCPtr, Actor.getCPtr(child));
+ if (SwigDerivedClassHasMethod("OnChildAdd", swigMethodTypes2)) NDalicPINVOKE.ViewImpl_OnChildAddSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildAdd(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- protected virtual new void OnChildRemove(Actor child)
+ protected virtual new void OnChildRemove(View child)
{
- if (SwigDerivedClassHasMethod("OnChildRemove", swigMethodTypes3)) NDalicPINVOKE.ViewImpl_OnChildRemoveSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildRemove(swigCPtr, Actor.getCPtr(child));
+ if (SwigDerivedClassHasMethod("OnChildRemove", swigMethodTypes3)) NDalicPINVOKE.ViewImpl_OnChildRemoveSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnChildRemove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
- protected virtual new float CalculateChildSize(Actor child, DimensionType dimension)
+ protected virtual new float CalculateChildSize(View child, DimensionType dimension)
{
- float ret = (SwigDerivedClassHasMethod("CalculateChildSize", swigMethodTypes14) ? NDalicPINVOKE.ViewImpl_CalculateChildSizeSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child), (int)dimension) : NDalicPINVOKE.ViewImpl_CalculateChildSize(swigCPtr, Actor.getCPtr(child), (int)dimension));
+ float ret = (SwigDerivedClassHasMethod("CalculateChildSize", swigMethodTypes14) ? NDalicPINVOKE.ViewImpl_CalculateChildSizeSwigExplicitViewImpl(swigCPtr, View.getCPtr(child), (int)dimension) : NDalicPINVOKE.ViewImpl_CalculateChildSize(swigCPtr, View.getCPtr(child), (int)dimension));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnControlChildAdd(Actor child)
+ public virtual void OnControlChildAdd(View child)
{
- if (SwigDerivedClassHasMethod("OnControlChildAdd", swigMethodTypes22)) NDalicPINVOKE.ViewImpl_OnControlChildAddSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildAdd(swigCPtr, Actor.getCPtr(child));
+ if (SwigDerivedClassHasMethod("OnControlChildAdd", swigMethodTypes22)) NDalicPINVOKE.ViewImpl_OnControlChildAddSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildAdd(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual void OnControlChildRemove(Actor child)
+ public virtual void OnControlChildRemove(View child)
{
- if (SwigDerivedClassHasMethod("OnControlChildRemove", swigMethodTypes23)) NDalicPINVOKE.ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildRemove(swigCPtr, Actor.getCPtr(child));
+ if (SwigDerivedClassHasMethod("OnControlChildRemove", swigMethodTypes23)) NDalicPINVOKE.ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(swigCPtr, View.getCPtr(child)); else NDalicPINVOKE.ViewImpl_OnControlChildRemove(swigCPtr, View.getCPtr(child));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public virtual Actor GetNextFocusableActor(Actor currentFocusedActor, View.FocusDirection direction, bool loopEnabled)
+ public virtual View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled)
{
- Actor ret = new Actor((SwigDerivedClassHasMethod("GetNextFocusableActor", swigMethodTypes32) ? NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(currentFocusedActor), (int)direction, loopEnabled) : NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActor(swigCPtr, Actor.getCPtr(currentFocusedActor), (int)direction, loopEnabled)), true);
+ View ret = new View((SwigDerivedClassHasMethod("GetNextFocusableView", swigMethodTypes32) ? NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(swigCPtr, View.getCPtr(currentFocusedView), (int)direction, loopEnabled) : NDalicPINVOKE.ViewImpl_GetNextKeyboardFocusableActor(swigCPtr, View.getCPtr(currentFocusedView), (int)direction, loopEnabled)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public virtual void OnFocusChangeCommitted(Actor commitedFocusableActor)
+ public virtual void OnFocusChangeCommitted(View commitedFocusableView)
{
- if (SwigDerivedClassHasMethod("OnFocusChangeCommitted", swigMethodTypes33)) NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(swigCPtr, Actor.getCPtr(commitedFocusableActor)); else NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommitted(swigCPtr, Actor.getCPtr(commitedFocusableActor));
+ if (SwigDerivedClassHasMethod("OnFocusChangeCommitted", swigMethodTypes33)) NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(swigCPtr, View.getCPtr(commitedFocusableView)); else NDalicPINVOKE.ViewImpl_OnKeyboardFocusChangeCommitted(swigCPtr, View.getCPtr(commitedFocusableView));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
swigDelegate30 = new SwigDelegateViewImpl_30(SwigDirectorOnKeyInputFocusGained);
if (SwigDerivedClassHasMethod("OnKeyInputFocusLost", swigMethodTypes31))
swigDelegate31 = new SwigDelegateViewImpl_31(SwigDirectorOnKeyInputFocusLost);
- if (SwigDerivedClassHasMethod("GetNextFocusableActor", swigMethodTypes32))
- swigDelegate32 = new SwigDelegateViewImpl_32(SwigDirectorGetNextKeyboardFocusableActor);
+ if (SwigDerivedClassHasMethod("GetNextFocusableView", swigMethodTypes32))
+ swigDelegate32 = new SwigDelegateViewImpl_32(SwigDirectorGetNextKeyboardFocusableView);
if (SwigDerivedClassHasMethod("OnFocusChangeCommitted", swigMethodTypes33))
swigDelegate33 = new SwigDelegateViewImpl_33(SwigDirectorOnKeyboardFocusChangeCommitted);
if (SwigDerivedClassHasMethod("OnKeyboardEnter", swigMethodTypes34))
private void SwigDirectorOnChildAdd(global::System.IntPtr child)
{
- OnChildAdd(new Actor(child, false));
+ OnChildAdd(new View(child, false));
}
private void SwigDirectorOnChildRemove(global::System.IntPtr child)
{
- OnChildRemove(new Actor(child, false));
+ OnChildRemove(new View(child, false));
}
private void SwigDirectorOnPropertySet(int index, global::System.IntPtr propertyValue)
private float SwigDirectorCalculateChildSize(global::System.IntPtr child, int dimension)
{
- return CalculateChildSize(new Actor(child, false), (DimensionType)dimension);
+ return CalculateChildSize(new View(child, false), (DimensionType)dimension);
}
private float SwigDirectorGetHeightForWidth(float width)
private void SwigDirectorOnControlChildAdd(global::System.IntPtr child)
{
- OnControlChildAdd(new Actor(child, false));
+ OnControlChildAdd(new View(child, false));
}
private void SwigDirectorOnControlChildRemove(global::System.IntPtr child)
{
- OnControlChildRemove(new Actor(child, false));
+ OnControlChildRemove(new View(child, false));
}
private void SwigDirectorOnStyleChange(global::System.IntPtr styleManager, int change)
OnKeyInputFocusLost();
}
- private global::System.IntPtr SwigDirectorGetNextKeyboardFocusableActor(global::System.IntPtr currentFocusedActor, int direction, bool loopEnabled)
+ private global::System.IntPtr SwigDirectorGetNextKeyboardFocusableView(global::System.IntPtr currentFocusedView, int direction, bool loopEnabled)
{
- return Actor.getCPtr(GetNextFocusableActor(new Actor(currentFocusedActor, true), (View.FocusDirection)direction, loopEnabled)).Handle;
+ return View.getCPtr(GetNextFocusableView(new View(currentFocusedView, true), (View.FocusDirection)direction, loopEnabled)).Handle;
}
- private void SwigDirectorOnKeyboardFocusChangeCommitted(global::System.IntPtr commitedFocusableActor)
+ private void SwigDirectorOnKeyboardFocusChangeCommitted(global::System.IntPtr commitedFocusableView)
{
- OnFocusChangeCommitted(new Actor(commitedFocusableActor, true));
+ OnFocusChangeCommitted(new View(commitedFocusableView, true));
}
private bool SwigDirectorOnKeyboardEnter()
private static global::System.Type[] swigMethodTypes0 = new global::System.Type[] { typeof(int) };
private static global::System.Type[] swigMethodTypes1 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(Actor) };
- private static global::System.Type[] swigMethodTypes3 = new global::System.Type[] { typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes2 = new global::System.Type[] { typeof(View) };
+ private static global::System.Type[] swigMethodTypes3 = new global::System.Type[] { typeof(View) };
private static global::System.Type[] swigMethodTypes4 = new global::System.Type[] { typeof(int), typeof(PropertyValue) };
private static global::System.Type[] swigMethodTypes5 = new global::System.Type[] { typeof(Vector3) };
private static global::System.Type[] swigMethodTypes6 = new global::System.Type[] { typeof(Animation), typeof(Vector3) };
private static global::System.Type[] swigMethodTypes11 = new global::System.Type[] { typeof(Vector2), typeof(RelayoutContainer) };
private static global::System.Type[] swigMethodTypes12 = new global::System.Type[] { typeof(ResizePolicyType), typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes13 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes14 = new global::System.Type[] { typeof(Actor), typeof(DimensionType) };
+ private static global::System.Type[] swigMethodTypes14 = new global::System.Type[] { typeof(View), typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes15 = new global::System.Type[] { typeof(float) };
private static global::System.Type[] swigMethodTypes16 = new global::System.Type[] { typeof(float) };
private static global::System.Type[] swigMethodTypes17 = new global::System.Type[] { typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes19 = new global::System.Type[] { typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes20 = new global::System.Type[] { typeof(float), typeof(DimensionType) };
private static global::System.Type[] swigMethodTypes21 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes22 = new global::System.Type[] { typeof(Actor) };
- private static global::System.Type[] swigMethodTypes23 = new global::System.Type[] { typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes22 = new global::System.Type[] { typeof(View) };
+ private static global::System.Type[] swigMethodTypes23 = new global::System.Type[] { typeof(View) };
private static global::System.Type[] swigMethodTypes24 = new global::System.Type[] { typeof(StyleManager), typeof(StyleChangeType) };
private static global::System.Type[] swigMethodTypes25 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes26 = new global::System.Type[] { typeof(PanGesture) };
private static global::System.Type[] swigMethodTypes29 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes30 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes31 = new global::System.Type[] { };
- private static global::System.Type[] swigMethodTypes32 = new global::System.Type[] { typeof(Actor), typeof(View.FocusDirection), typeof(bool) };
- private static global::System.Type[] swigMethodTypes33 = new global::System.Type[] { typeof(Actor) };
+ private static global::System.Type[] swigMethodTypes32 = new global::System.Type[] { typeof(View), typeof(View.FocusDirection), typeof(bool) };
+ private static global::System.Type[] swigMethodTypes33 = new global::System.Type[] { typeof(View) };
private static global::System.Type[] swigMethodTypes34 = new global::System.Type[] { };
private static global::System.Type[] swigMethodTypes35 = new global::System.Type[] { typeof(PinchGesture) };
private static global::System.Type[] swigMethodTypes36 = new global::System.Type[] { typeof(PanGesture) };
{
// Create the control
CustomView newControl = controlConstructor();
- return newControl.GetPtrfromActor(); // return pointer to handle
+ return newControl.GetPtrfromView(); // return pointer to handle
}
else
{
}
}
- public static View GetViewFromActor(Actor actor)
+ public static View GetViewFromActor(View view)
{
// we store a dictionary of ref-obects (C++ land) to custom views (C# land)
- RefObject refObj = actor.GetObjectPtr();
+ RefObject refObj = view.GetObjectPtr();
IntPtr refObjectPtr = (IntPtr)RefObject.getCPtr(refObj);
WeakReference viewReference;
if (Instance._controlMap.TryGetValue(refObjectPtr, out viewReference))
{
- View view = viewReference.Target as View;
- return view;
+ View retview = viewReference.Target as View;
+ return retview;
}
else
{
--- /dev/null
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.12
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+using Tizen.NUI.BaseComponents;
+
+namespace Tizen.NUI {
+
+public class ViewResourceReadySignal : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal ViewResourceReadySignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewResourceReadySignal obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~ViewResourceReadySignal() {
+ DisposeQueue.Instance.Add(this);
+ }
+
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_ViewResourceReadySignal(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+
+ public bool Empty() {
+ bool ret = NDalicPINVOKE.ViewResourceReadySignal_Empty(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public uint GetConnectionCount() {
+ uint ret = NDalicPINVOKE.ViewResourceReadySignal_GetConnectionCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Connect(System.Delegate func) {
+System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
+ {
+ NDalicPINVOKE.ViewResourceReadySignal_Connect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ }
+
+ public void Disconnect(System.Delegate func) {
+System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
+ {
+ NDalicPINVOKE.ViewResourceReadySignal_Disconnect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ }
+
+ public void Emit(View arg) {
+ NDalicPINVOKE.ViewResourceReadySignal_Emit(swigCPtr, View.getCPtr(arg));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public ViewResourceReadySignal() : this(NDalicPINVOKE.new_ViewResourceReadySignal(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+}
+
+}
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// Version 3.0.10
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
-internal class ActorSignal : global::System.IDisposable {
+ using Tizen.NUI.BaseComponents;\r
+ public class ViewSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal ViewSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorSignal() {
+ ~ViewSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public void Emit(Actor arg) {
- NDalicPINVOKE.ActorSignal_Emit(swigCPtr, Actor.getCPtr(arg));
+ public void Emit(View arg) {
+ NDalicPINVOKE.ActorSignal_Emit(swigCPtr, View.getCPtr(arg));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public ActorSignal() : this(NDalicPINVOKE.new_ActorSignal(), true) {
+ public ViewSignal() : this(NDalicPINVOKE.new_ActorSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
--- /dev/null
+//------------------------------------------------------------------------------
+// <auto-generated />
+//
+// This file was automatically generated by SWIG (http://www.swig.org).
+// Version 3.0.12
+//
+// Do not make changes to this file unless you know what you are doing--modify
+// the SWIG interface file instead.
+//------------------------------------------------------------------------------
+using Tizen.NUI.BaseComponents;
+namespace Tizen.NUI {
+
+public class ViewVisibilityChangedSignal : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal ViewVisibilityChangedSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ViewVisibilityChangedSignal obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~ViewVisibilityChangedSignal() {
+ DisposeQueue.Instance.Add(this);
+ }
+
+ public virtual void Dispose() {
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_ViewVisibilityChangedSignal(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+ public bool Empty() {
+ bool ret = NDalicPINVOKE.ViewVisibilityChangedSignal_Empty(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public uint GetConnectionCount() {
+ uint ret = NDalicPINVOKE.ViewVisibilityChangedSignal_GetConnectionCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Connect(System.Delegate func) {
+System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
+ {
+ NDalicPINVOKE.ViewVisibilityChangedSignal_Connect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ }
+
+ public void Disconnect(System.Delegate func) {
+System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
+ {
+ NDalicPINVOKE.ViewVisibilityChangedSignal_Disconnect(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ }
+
+ public void Emit(View arg) {
+ NDalicPINVOKE.ViewVisibilityChangedSignal_Emit(swigCPtr, View.getCPtr(arg));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public ViewVisibilityChangedSignal() : this(NDalicPINVOKE.new_ViewVisibilityChangedSignal(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+}
+
+}
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
public delegate void OnStageConnectionDelegate(int depth);
public delegate void OnStageDisconnectionDelegate();
- public delegate void OnChildAddDelegate(Actor actor);
- public delegate void OnChildRemoveDelegate(Actor actor);
+ public delegate void OnChildAddDelegate(View view);
+ public delegate void OnChildRemoveDelegate(View view);
public delegate void OnPropertySetDelegate(int index, PropertyValue propertyValue);
public delegate void OnSizeSetDelegate(Vector3 targetSize);
public delegate void OnSizeAnimationDelegate(Animation animation, Vector3 targetSize);
public delegate void OnRelayoutDelegate(Vector2 size, RelayoutContainer container);
public delegate void OnSetResizePolicyDelegate(ResizePolicyType policy, DimensionType dimension);
public delegate Size GetNaturalSizeDelegate();
- public delegate float CalculateChildSizeDelegate(Actor child, DimensionType dimension);
+ public delegate float CalculateChildSizeDelegate(View child, DimensionType dimension);
public delegate float GetHeightForWidthDelegate(float width);
public delegate float GetWidthForHeightDelegate(float height);
public delegate bool RelayoutDependentOnChildrenDimensionDelegate(DimensionType dimension);
public delegate bool RelayoutDependentOnChildrenDelegate();
public delegate void OnCalculateRelayoutSizeDelegate(DimensionType dimension);
public delegate void OnLayoutNegotiatedDelegate(float size, DimensionType dimension);
- public delegate void OnControlChildAddDelegate(Actor child);
- public delegate void OnControlChildRemoveDelegate(Actor child);
+ public delegate void OnControlChildAddDelegate(View child);
+ public delegate void OnControlChildRemoveDelegate(View child);
public delegate void OnStyleChangeDelegate(StyleManager styleManager, StyleChangeType change);
public delegate bool OnAccessibilityActivatedDelegate();
public delegate bool OnAccessibilityPanDelegate(PanGesture gestures);
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
return ret;
}
- public float CalculateChildSizeBase(Actor child, DimensionType dimension)
+ public float CalculateChildSizeBase(View child, DimensionType dimension)
{
- float ret = NDalicManualPINVOKE.ViewWrapperImpl_CalculateChildSizeBase(swigCPtr, Actor.getCPtr(child), (int)dimension);
+ float ret = NDalicManualPINVOKE.ViewWrapperImpl_CalculateChildSizeBase(swigCPtr, View.getCPtr(child), (int)dimension);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
private void DirectorOnChildAdd(global::System.IntPtr child)
{
- OnChildAdd(new Actor(child, false));
+ OnChildAdd(new View(child, false));
}
private void DirectorOnChildRemove(global::System.IntPtr child)
{
- OnChildRemove(new Actor(child, false));
+ OnChildRemove(new View(child, false));
}
private void DirectorOnPropertySet(int index, global::System.IntPtr propertyValue)
private float DirectorCalculateChildSize(global::System.IntPtr child, int dimension)
{
- return CalculateChildSize(new Actor(child, false), (DimensionType)dimension);
+ return CalculateChildSize(new View(child, false), (DimensionType)dimension);
}
private float DirectorGetHeightForWidth(float width)
private void DirectorOnControlChildAdd(global::System.IntPtr child)
{
- OnControlChildAdd(new Actor(child, false));
+ OnControlChildAdd(new View(child, false));
}
private void DirectorOnControlChildRemove(global::System.IntPtr child)
{
- OnControlChildRemove(new Actor(child, false));
+ OnControlChildRemove(new View(child, false));
}
private void DirectorOnStyleChange(global::System.IntPtr styleManager, int change)
private global::System.IntPtr DirectorGetNextFocusableActor(global::System.IntPtr currentFocusedActor, int direction, bool loopEnabled)
{
- return Actor.getCPtr(GetNextFocusableView(new View(currentFocusedActor, false), (View.FocusDirection)direction, loopEnabled)).Handle;
+ return View.getCPtr(GetNextFocusableView(new View(currentFocusedActor, false), (View.FocusDirection)direction, loopEnabled)).Handle;
}
private void DirectorOnFocusChangeCommitted(global::System.IntPtr commitedFocusableView)
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.12
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-/* moved to VisualMaps.cs
-namespace Tizen.NUI {
-
-public enum VisualTransformPolicyType {
- RELATIVE = 0,
- ABSOLUTE = 1
-}
-
-}
-*/
\ No newline at end of file
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-/* moved to VisualMaps.cs
-namespace Tizen.NUI {
-
-public enum VisualTransformPropertyType {
- OFFSET,
- SIZE,
- ORIGIN,
- ANCHOR_POINT,
- OFFSET_POLICY,
- SIZE_POLICY
-}
-
-}
-*/
\ No newline at end of file
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// Version 3.0.10
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
namespace Tizen.NUI {
-
- internal class ActorWheelSignal : global::System.IDisposable {
+ using Tizen.NUI.BaseComponents;
+internal class WheelSignal : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
- internal ActorWheelSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ internal WheelSignal(global::System.IntPtr cPtr, bool cMemoryOwn) {
swigCMemOwn = cMemoryOwn;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
}
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ActorWheelSignal obj) {
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WheelSignal obj) {
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- ~ActorWheelSignal() {
+ ~WheelSignal() {
DisposeQueue.Instance.Add(this);
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
}
- public bool Emit(Actor arg1, Wheel arg2) {
- bool ret = NDalicPINVOKE.ActorWheelSignal_Emit(swigCPtr, Actor.getCPtr(arg1), Wheel.getCPtr(arg2));
+ public bool Emit(View arg1, Wheel arg2) {
+ bool ret = NDalicPINVOKE.ActorWheelSignal_Emit(swigCPtr, View.getCPtr(arg1), Wheel.getCPtr(arg2));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- public ActorWheelSignal() : this(NDalicPINVOKE.new_ActorWheelSignal(), true) {
+ public WheelSignal() : this(NDalicPINVOKE.new_ActorWheelSignal(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI {
-/* move to VisualMap.cs
- internal enum WrapModeType {
- DEFAULT = 0,
- CLAMP_TO_EDGE,
- REPEAT,
- MIRRORED_REPEAT
-}
-*/
-}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
+++ /dev/null
-// Copyright (c) 2017 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.
-//
-//
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-// Some have been manually changed
-
-
-namespace Tizen.NUI
-{
-
- using System;
- using System.Runtime.InteropServices;
-
- /// <summary>
- /// Actor is the primary object with which Dali applications interact.<br>
- /// UI controls can be built by combining multiple actors.<br>
- /// </summary>
- public class Actor : Handle
- {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal Actor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Actor_SWIGUpcast(cPtr), cMemoryOwn)
- {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Actor obj)
- {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- /// <summary>
- /// To make Actor instance be disposed.
- /// </summary>
- public override void Dispose()
- {
- if (!Stage.IsInstalled())
- {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock (this)
- {
- if (swigCPtr.Handle != global::System.IntPtr.Zero)
- {
- if (swigCMemOwn)
- {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Actor(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
-
- internal static Actor GetActorFromPtr(global::System.IntPtr cPtr)
- {
- Actor ret = new Actor(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal IntPtr GetPtrfromActor()
- {
- return (IntPtr)swigCPtr;
- }
-
- /// <summary>
- /// Retrieves the position of the Actor.<br>
- /// The coordinates are relative to the Actor's parent.<br>
- /// </summary>
- public Position CurrentPosition
- {
- get
- {
- return GetCurrentPosition();
- }
- }
-
- /// <summary>
- /// Retrieves the size of the Actor.<br>
- /// The coordinates are relative to the Actor's parent.<br>
- /// </summary>
- public Size CurrentSize
- {
- get
- {
- return GetCurrentSize();
- }
- }
-
- /// <summary>
- /// Retrieves the actor's parent.<br>
- /// </summary>
- public Actor Parent
- {
- get
- {
- return GetParent();
- }
- }
-
- /// <summary>
- /// Retrieves and sets the actor's opacity.<br>
- /// </summary>
- public float Opacity
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Retrieves screen postion of actor's.<br>
- /// </summary>
- public Vector2 ScreenPosition
- {
- get
- {
- Vector2 temp = new Vector2(0.0f, 0.0f);
- GetProperty(Actor.Property.SCREEN_POSITION).Get(temp);
- return temp;
- }
- }
-
- /// <summary>
- /// Determines whether the anchor point should be used to determine the position of the actor.
- /// This is true by default.
- /// </summary>
- /// <remarks>If false, then the top-left of the actor is used for the position.
- /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the actor's position.
- /// </remarks>
- public bool PositionUsesAnchorPoint
- {
- get
- {
- bool temp = false;
- if(this) GetProperty(Actor.Property.POSITION_USES_ANCHOR_POINT).Get(ref temp);
- return temp;
- }
- set
- {
- if(this) SetProperty(Actor.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Queries whether the actor is connected to the Stage.<br>
- /// When an actor is connected, it will be directly or indirectly parented to the root Actor.<br>
- /// </summary>
- public bool IsOnStage
- {
- get
- {
- return OnStage();
- }
- }
-
- /// <summary>
- /// Gets depth in the hierarchy for the actor.
- /// </summary>
- public int HierarchyDepth
- {
- get
- {
- return GetHierarchyDepth();
- }
- }
-
- /// <summary>
- /// Sets the sibling order of the actor so depth position can be defined within the same parent.
- /// </summary>
- /// <remarks>
- /// Note The initial value is 0.
- /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.
- /// The values set by this Property will likely change.
- /// </remarks>
- public int SiblingOrder
- {
- get
- {
- int temp = 0;
- GetProperty(Actor.Property.SIBLING_ORDER).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Sets the size of an actor for width and height.<br>
- /// Geometry can be scaled to fit within this area.<br>
- /// This does not interfere with the actors scale factor.<br>
- /// The actors default depth is the minimum of width & height.<br>
- /// </summary>
- public Size2D Size2D
- {
- get
- {
- Size temp = new Size(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.SIZE).Get(temp);
- return new Size2D(temp);
- }
- set
- {
- SetProperty(Actor.Property.SIZE, new PropertyValue(new Size(value)));
- }
- }
-
- /// <summary>
- /// Sets the position of the Actor for X and Y.<br>
- /// By default, sets the position vector between the parent origin and anchor point(default).<br>
- /// If Position inheritance if disabled, sets the world position.<br>
- /// </summary>
- public Position2D Position2D
- {
- get
- {
- Position temp = new Position(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.POSITION).Get(temp);
- return new Position2D(temp);
- }
- set
- {
- SetProperty(Actor.Property.POSITION, new PropertyValue(new Position(value)));
- }
- }
-
- /// <summary>
- /// Shows the Actor.
- /// </summary>
- /// <remarks>
- /// This is an asynchronous method.
- /// </remarks>
- public void Show()
- {
- SetVisible(true);
- }
-
- /// <summary>
- /// Hides the Actor.
- /// </summary>
- /// <remarks>
- /// This is an asynchronous method.
- /// If an actor is hidden, then the actor and its children will not be rendered.
- /// This is regardless of the individual visibility of the children i.e.an actor will only be rendered if all of its parents are shown.
- /// </remarks>
- public void Hide()
- {
- SetVisible(false);
- }
-
- /// <summary>
- /// Raise actor above the next highest level of actor(s).
- /// </summary>
- /// <remarks>
- /// Sibling order of actors within the parent will be updated automatically.
- /// Initially actors added to a parent will have the same sibling order and shown in relation to insertion order.
- /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- public void Raise()
- {
- NDalicPINVOKE.Raise(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Lower the actor to underneath the level below actor(s).
- /// </summary>
- /// <remarks>
- /// Sibling order of actors within the parent will be updated automatically.
- /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- public void Lower()
- {
- NDalicPINVOKE.Lower(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Raise actor above all other actors.
- /// </summary>
- /// <remarks>
- /// Sibling order of actors within the parent will be updated automatically.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- public void RaiseToTop()
- {
- NDalicPINVOKE.RaiseToTop(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Lower actor to the bottom of all actors.
- /// </summary>
- /// <remarks>
- /// Sibling order of actors within the parent will be updated automatically.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- public void LowerToBottom()
- {
- NDalicPINVOKE.LowerToBottom(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Raise the actor to above the target actor.
- /// </summary>
- /// <remarks>Sibling order of actors within the parent will be updated automatically.
- /// Actors on the level above the target actor will still be shown above this actor.
- /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- /// <param name="target">Will be raised above this actor</param>
- public void RaiseAbove(Actor target)
- {
- NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Lower the actor to below the target actor.
- /// </summary>
- /// <remarks>Sibling order of actors within the parent will be updated automatically.
- /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
- /// </remarks>
- /// <param name="target">Will be lowered below this actor</param>
- public void LowerBelow(Actor target)
- {
- NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
-
- internal class Property : global::System.IDisposable
- {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- protected bool swigCMemOwn;
-
- internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
- {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
- {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Property()
- {
- Dispose();
- }
-
- public virtual void Dispose()
- {
- lock (this)
- {
- if (swigCPtr.Handle != global::System.IntPtr.Zero)
- {
- if (swigCMemOwn)
- {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Actor_Property(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-
- internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
- internal static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
- internal static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
- internal static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
-
- internal Property() : this(NDalicPINVOKE.new_Actor_Property(), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
- internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
- internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
- internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
- internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
- internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
- internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
- internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
- internal static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
- internal static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
- internal static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
- internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
- internal static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
- internal static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
- internal static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
- internal static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
- internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
- internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
- internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
- internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
- internal static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
- internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
- internal static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
- internal static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
- internal static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
- internal static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
- internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
- internal static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
- internal static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
- internal static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
- internal static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
- internal static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
- internal static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
- internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
- internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
- internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
- internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
- internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
- internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
- internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
- internal static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
- internal static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
- internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
- internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
- internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
- internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
- internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
- internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
- internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
- internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
- internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
- internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
- internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
- internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
-
- }
-
- /// <summary>
- /// Creates an initialized Actor.
- /// </summary>
- public Actor() : this(NDalicPINVOKE.Actor_New(), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
-
- /// <summary>
- /// Downcasts a handle to Actor handle.<br>
- /// If handle points to an Actor object, the downcast produces valid handle.<br>
- /// If not, the returned handle is left uninitialized.<br>
- /// </summary>
- /// <param name="handle">handle to An object</param>
- /// <returns>handle to an Actor object or an uninitialized handle</returns>
- public new static Actor DownCast(BaseHandle handle)
- {
- Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Actor(Actor copy) : this(NDalicPINVOKE.new_Actor__SWIG_1(Actor.getCPtr(copy)), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Actor Assign(Actor rhs)
- {
- Actor ret = new Actor(NDalicPINVOKE.Actor_Assign(swigCPtr, Actor.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal string GetName()
- {
- string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetName(string name)
- {
- NDalicPINVOKE.Actor_SetName(swigCPtr, name);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal uint GetId()
- {
- uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal bool IsRoot()
- {
- bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal bool OnStage()
- {
- bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal bool IsLayer()
- {
- bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Layer GetLayer()
- {
- Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Adds a child Actor to this Actor.
- /// </summary>
- /// <pre>This Actor(the parent) has been initialized. The child actor has been initialized. The child actor is not the same as the parent actor.</pre>
- /// <post>The child will be referenced by its parent. This means that the child will be kept alive, even if the handle passed into this method is reset or destroyed.</post>
- /// <remarks>If the child already has a parent, it will be removed from old parent and reparented to this actor. This may change child's position, color, scale etc as it now inherits them from this actor.</remarks>
- /// <param name="child">The child</param>
- public void Add(Actor child)
- {
- NDalicPINVOKE.Actor_Add(swigCPtr, Actor.getCPtr(child));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Removes a child Actor from this Actor. If the actor was not a child of this actor, this is a no-op.
- /// </summary>
- /// <pre>This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.</pre>
- /// <param name="child">The child</param>
- public void Remove(Actor child)
- {
- NDalicPINVOKE.Actor_Remove(swigCPtr, Actor.getCPtr(child));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void Unparent()
- {
- NDalicPINVOKE.Actor_Unparent(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Retrieves the number of children held by the actor.
- /// </summary>
- /// <pre>The Actor has been initialized.</pre>
- /// <returns>The number of children</returns>
- public uint GetChildCount()
- {
- uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Retrieves child actor by index.
- /// </summary>
- /// <pre>The Actor has been initialized.</pre>
- /// <param name="index">The index of the child to retrieve</param>
- /// <returns>The actor for the given index or empty handle if children not initialized</returns>
- public Actor GetChildAt(uint index)
- {
- Actor ret = new Actor(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Search through this actor's hierarchy for an actor with the given name.
- /// The actor itself is also considered in the search.
- /// </summary>
- /// <pre>The Actor has been initialized.</pre>
- /// <param name="actorName">The name of the actor to find</param>
- /// <returns>A handle to the actor if found, or an empty handle if not</returns>
- public Actor FindChildByName(string actorName)
- {
- Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Actor FindChildById(uint id)
- {
- Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Actor GetParent()
- {
- Actor ret = new Actor(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetParentOrigin(Vector3 origin)
- {
- NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector3 GetCurrentParentOrigin()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetAnchorPoint(Vector3 anchorPoint)
- {
- NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector3 GetCurrentAnchorPoint()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetSize(float width, float height)
- {
- NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetSize(float width, float height, float depth)
- {
- NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetSize(Vector2 size)
- {
- NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetSize(Vector3 size)
- {
- NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector3 GetTargetSize()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Size GetCurrentSize()
- {
- Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Returns the natural size of the actor.<br>
- /// Deriving classes stipulate the natural size and by default an actor has a ZERO natural size.<br>
- /// </summary>
- /// <returns>The actor's natural size</returns>
- public Vector3 GetNaturalSize()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetPosition(float x, float y)
- {
- NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetPosition(float x, float y, float z)
- {
- NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetPosition(Vector3 position)
- {
- NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetX(float x)
- {
- NDalicPINVOKE.Actor_SetX(swigCPtr, x);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetY(float y)
- {
- NDalicPINVOKE.Actor_SetY(swigCPtr, y);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetZ(float z)
- {
- NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void TranslateBy(Vector3 distance)
- {
- NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Position GetCurrentPosition()
- {
- Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Vector3 GetCurrentWorldPosition()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetInheritPosition(bool inherit)
- {
- NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal PositionInheritanceMode GetPositionInheritanceMode()
- {
- PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal bool IsPositionInherited()
- {
- bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetOrientation(Degree angle, Vector3 axis)
- {
- NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetOrientation(Radian angle, Vector3 axis)
- {
- NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetOrientation(Rotation orientation)
- {
- NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void RotateBy(Degree angle, Vector3 axis)
- {
- NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void RotateBy(Radian angle, Vector3 axis)
- {
- NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void RotateBy(Rotation relativeRotation)
- {
- NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Rotation GetCurrentOrientation()
- {
- Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetInheritOrientation(bool inherit)
- {
- NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool IsOrientationInherited()
- {
- bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Rotation GetCurrentWorldOrientation()
- {
- Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetScale(float scale)
- {
- NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetScale(float scaleX, float scaleY, float scaleZ)
- {
- NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetScale(Vector3 scale)
- {
- NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void ScaleBy(Vector3 relativeScale)
- {
- NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector3 GetCurrentScale()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Vector3 GetCurrentWorldScale()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetInheritScale(bool inherit)
- {
- NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool IsScaleInherited()
- {
- bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Matrix GetCurrentWorldMatrix()
- {
- Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetVisible(bool visible)
- {
- NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool IsVisible()
- {
- bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetOpacity(float opacity)
- {
- NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal float GetCurrentOpacity()
- {
- float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetColor(Vector4 color)
- {
- NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector4 GetCurrentColor()
- {
- Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetColorMode(ColorMode colorMode)
- {
- NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal ColorMode GetColorMode()
- {
- ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Vector4 GetCurrentWorldColor()
- {
- Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetDrawMode(DrawModeType drawMode)
- {
- NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal DrawModeType GetDrawMode()
- {
- DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetSensitive(bool sensitive)
- {
- NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool IsSensitive()
- {
- bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Converts screen coordinates into the actor's coordinate system using the default camera.
- /// </summary>
- /// <pre>The Actor has been initialized.</pre>
- /// <remarks>The actor coordinates are relative to the top-left(0.0, 0.0, 0.5)</remarks>
- /// <param name="localX">On return, the X-coordinate relative to the actor</param>
- /// <param name="localY">On return, the Y-coordinate relative to the actor</param>
- /// <param name="screenX">The screen X-coordinate</param>
- /// <param name="screenY">The screen Y-coordinate</param>
- /// <returns>True if the conversion succeeded</returns>
- public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
- {
- bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetLeaveRequired(bool required)
- {
- NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool GetLeaveRequired()
- {
- bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetKeyboardFocusable(bool focusable)
- {
- NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool IsKeyboardFocusable()
- {
- bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
- {
- NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal ResizePolicyType GetResizePolicy(DimensionType dimension)
- {
- ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetSizeScalePolicy(SizeScalePolicyType policy)
- {
- NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal SizeScalePolicyType GetSizeScalePolicy()
- {
- SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Sets the relative to parent size factor of the actor.<br>
- /// This factor is only used when ResizePolicy is set to either:
- /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br>
- /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicy.<br>
- /// </summary>
- /// <pre>The Actor has been initialized.</pre>
- /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
- public void SetSizeModeFactor(Vector3 factor)
- {
- NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector3 GetSizeModeFactor()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Calculates the height of the actor given a width.<br>
- /// The natural size is used for default calculation. <br>
- /// size 0 is treated as aspect ratio 1:1.<br>
- /// </summary>
- /// <param name="width">Width to use</param>
- /// <returns>The height based on the width</returns>
- public float GetHeightForWidth(float width)
- {
- float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Calculates the width of the actor given a height.<br>
- /// The natural size is used for default calculation.<br>
- /// size 0 is treated as aspect ratio 1:1.<br>
- /// </summary>
- /// <param name="height">Height to use</param>
- /// <returns>The width based on the height</returns>
- public float GetWidthForHeight(float height)
- {
- float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- public float GetRelayoutSize(DimensionType dimension)
- {
- float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Sets the padding for use in layout.<br>
- /// </summary>
- /// <param name="padding">Padding for the actor</param>
- public void SetPadding(PaddingType padding)
- {
- NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Returns the value of the padding.<br>
- /// </summary>
- /// <param name="paddingOut">The returned padding data</param>
- public void GetPadding(PaddingType paddingOut)
- {
- NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetMinimumSize(Vector2 size)
- {
- NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector2 GetMinimumSize()
- {
- Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetMaximumSize(Vector2 size)
- {
- NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector2 GetMaximumSize()
- {
- Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal int GetHierarchyDepth()
- {
- int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal uint AddRenderer(Renderer renderer)
- {
- uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal uint GetRendererCount()
- {
- uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Renderer GetRendererAt(uint index)
- {
- Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void RemoveRenderer(Renderer renderer)
- {
- NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void RemoveRenderer(uint index)
- {
- NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t TouchedSignal()
- {
- SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t ret = new SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t(NDalicPINVOKE.Actor_TouchedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ActorTouchDataSignal TouchSignal()
- {
- ActorTouchDataSignal ret = new ActorTouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ActorHoverSignal HoveredSignal()
- {
- ActorHoverSignal ret = new ActorHoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ActorWheelSignal WheelEventSignal()
- {
- ActorWheelSignal ret = new ActorWheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ActorSignal OnStageSignal()
- {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ActorSignal OffStageSignal()
- {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ActorSignal OnRelayoutSignal()
- {
- ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Gets/Sets the origin of an actor, within its parent's area.<br>
- /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.<br>
- /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br>
- /// An actor's position is the distance between this origin, and the actor's anchor-point.<br>
- /// </summary>
- /// <pre>The Actor has been initialized.</pre>
- public Position ParentOrigin
- {
- get
- {
- Position temp = new Position(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.PARENT_ORIGIN).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the anchor-point of an actor.<br>
- /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the actor, and (1.0, 1.0, 0.5) is the bottom-right corner.<br>
- /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).<br>
- /// An actor position is the distance between its parent-origin and this anchor-point.<br>
- /// An actor's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br>
- /// <pre>The Actor has been initialized.</pre>
- /// </summary>
- public Position AnchorPoint
- {
- get
- {
- Position temp = new Position(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.ANCHOR_POINT).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
- }
- }
-
-
- /// <summary>
- /// Gets/Sets the size of an actor.<br>
- /// Geometry can be scaled to fit within this area.<br>
- /// This does not interfere with the actors scale factor.<br>
- /// </summary>
- public Size Size
- {
- get
- {
- Size temp = new Size(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.SIZE).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SIZE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the size width of an actor.
- /// </summary>
- public float SizeWidth
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.SIZE_WIDTH).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the size height of an actor.
- /// </summary>
- public float SizeHeight
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.SIZE_HEIGHT).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the size depth of an actor.
- /// </summary>
- public float SizeDepth
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.SIZE_DEPTH).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the position of the Actor.<br>
- /// By default, sets the position vector between the parent origin and anchor point(default).<br>
- /// If Position inheritance if disabled, sets the world position.<br>
- /// </summary>
- public Position Position
- {
- get
- {
- Position temp = new Position(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.POSITION).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.POSITION, new Tizen.NUI.PropertyValue(value));
- }
- }
-
-
- /// <summary>
- /// Gets/Sets the position x of the Actor.
- /// </summary>
- public float PositionX
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.POSITION_X).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the position y of the Actor.
- /// </summary>
- public float PositionY
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.POSITION_Y).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the position z of the Actor.
- /// </summary>
- public float PositionZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.POSITION_Z).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the world position of the Actor.
- /// </summary>
- public Vector3 WorldPosition
- {
- get
- {
- Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.WORLD_POSITION).Get(temp);
- return temp;
- }
- }
-
- /// <summary>
- /// Gets/Sets the orientation of the Actor.<br>
- /// An actor's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br>
- /// </summary>
- /// <remarks>This is an asynchronous method.</remarks>
- public Rotation Orientation
- {
- get
- {
- Rotation temp = new Rotation();
- GetProperty(Actor.Property.ORIENTATION).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the world orientation of the Actor.<br>
- /// </summary>
- public Rotation WorldOrientation
- {
- get
- {
- Rotation temp = new Rotation();
- GetProperty(Actor.Property.WORLD_ORIENTATION).Get(temp);
- return temp;
- }
- }
-
- /// <summary>
- /// Gets/Sets the scale factor applied to an actor.<br>
- /// </summary>
- public Vector3 Scale
- {
- get
- {
- Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.SCALE).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SCALE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the scale x factor applied to an actor.
- /// </summary>
- public float ScaleX
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.SCALE_X).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the scale y factor applied to an actor.
- /// </summary>
- public float ScaleY
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.SCALE_Y).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the scale z factor applied to an actor.
- /// </summary>
- public float ScaleZ
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.SCALE_Z).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets the world scale of Actor.
- /// </summary>
- public Vector3 WorldScale
- {
- get
- {
- Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.WORLD_SCALE).Get(temp);
- return temp;
- }
- }
-
- /// <summary>
- /// Retrieves the visibility flag of an actor.
- /// </summary>
- /// <remarks>
- /// If an actor is not visible, then the actor and its children will not be rendered.
- /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.
- /// </remarks>
- public bool Visible
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.VISIBLE).Get(ref temp);
- return temp;
- }
- /* only get is required : removed
- set
- {
- SetProperty(Actor.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
- }
- */
- }
-
- /*
- public Color MixColor
- {
- get
- {
- Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.COLOR).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.COLOR, new Tizen.NUI.PropertyValue(value));
- }
- }
- */
-
- /// <summary>
- /// Gets/Sets the actor's mix color red.
- /// </summary>
- public float ColorRed
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.COLOR_RED).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.COLOR_RED, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the actor's mix color green.
- /// </summary>
- public float ColorGreen
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.COLOR_GREEN).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.COLOR_GREEN, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the actor's mix color blue
- /// </summary>
- public float ColorBlue
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.COLOR_BLUE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.COLOR_BLUE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the actor's mix color alpha.
- /// </summary>
- public float ColorAlpha
- {
- get
- {
- float temp = 0.0f;
- GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets the actor's world color.
- /// </summary>
- public Color WorldColor
- {
- get
- {
- Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.WORLD_COLOR).Get(temp);
- return temp;
- }
- }
-
- /// <summary>
- /// Gets/Sets the Actor's name.
- /// </summary>
- public string Name
- {
- get
- {
- string temp;
- GetProperty(Actor.Property.NAME).Get(out temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.NAME, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the status of whether an actor should emit touch or hover signals.
- /// </summary>
- public bool Sensitive
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.SENSITIVE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the status of whether the actor should receive a notification when touch or hover motion events leave the boundary of the actor.
- /// </summary>
- public bool LeaveRequired
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.LEAVE_REQUIRED).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the status of whether a child actor inherits it's parent's orientation.
- /// </summary>
- public bool InheritOrientation
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.INHERIT_ORIENTATION).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the status of whether a child actor inherits it's parent's scale.
- /// </summary>
- public bool InheritScale
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.INHERIT_SCALE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the actor's color mode.<br>
- /// This specifies whether the Actor uses its own color, or inherits its parent color.<br>
- /// The default is UseOwnMultiplyParentAlpha.<br>
- /// </summary>
- public ColorMode ColorMode
- {
- get
- {
- string temp;
- if (GetProperty(Actor.Property.COLOR_MODE).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "ColorMode get error!");
-#endif
- }
- switch (temp)
- {
- case "USE_OWN_COLOR":
- return ColorMode.UseOwnColor;
- case "USE_PARENT_COLOR":
- return ColorMode.UseParentColor;
- case "USE_OWN_MULTIPLY_PARENT_COLOR":
- return ColorMode.UseOwnMultiplyParentColor;
- case "USE_OWN_MULTIPLY_PARENT_ALPHA":
- return ColorMode.UseOwnMultiplyParentAlpha;
- default:
- return ColorMode.UseOwnMultiplyParentAlpha;
- }
- }
- set
- {
- SetProperty(Actor.Property.COLOR_MODE, new Tizen.NUI.PropertyValue((int)value));
- }
- }
-
-
- /// <summary>
- /// Gets/Sets the status of how the actor and its children should be drawn.<br>
- /// Not all actors are renderable, but DrawMode can be inherited from any actor.<br>
- /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.<br>
- /// If DrawMode.Overlay2D is used, the actor and its children will be drawn as a 2D overlay.<br>
- /// Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.<br>
- /// For overlay actors, the drawing order is with respect to tree levels of Actors, and depth-testing will not be used.<br>
- /// </summary>
- public DrawModeType DrawMode
- {
- get
- {
- string temp;
- if (GetProperty(Actor.Property.DRAW_MODE).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "DrawMode get error!");
-#endif
- }
- switch (temp)
- {
- case "NORMAL":
- return DrawModeType.Normal;
- case "OVERLAY_2D":
- return DrawModeType.Overlay2D;
- case "STENCIL":
- return DrawModeType.Stencil;
- default:
- return DrawModeType.Normal;
- }
- }
- set
- {
- SetProperty(Actor.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the relative to parent size factor of the actor.<br>
- /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br>
- /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicyType.<br>
- /// </summary>
- public Vector3 SizeModeFactor
- {
- get
- {
- Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.SIZE_MODE_FACTOR).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the width resize policy to be used.
- /// </summary>
- public ResizePolicyType WidthResizePolicy
- {
- get
- {
- string temp;
- if (GetProperty(Actor.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "WidthResizePolicy get error!");
-#endif
- }
- switch (temp)
- {
- case "FIXED":
- return ResizePolicyType.Fixed;
- case "USE_NATURAL_SIZE":
- return ResizePolicyType.UseNaturalSize;
- case "FILL_TO_PARENT":
- return ResizePolicyType.FillToParent;
- case "SIZE_RELATIVE_TO_PARENT":
- return ResizePolicyType.SizeRelativeToParent;
- case "SIZE_FIXED_OFFSET_FROM_PARENT":
- return ResizePolicyType.SizeFixedOffsetFromParent;
- case "FIT_TO_CHILDREN":
- return ResizePolicyType.FitToChildren;
- case "DIMENSION_DEPENDENCY":
- return ResizePolicyType.DimensionDependency;
- case "USE_ASSIGNED_SIZE":
- return ResizePolicyType.UseAssignedSize;
- default:
- return ResizePolicyType.Fixed;
- }
- }
- set
- {
- SetProperty(Actor.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the height resize policy to be used.
- /// </summary>
- public ResizePolicyType HeightResizePolicy
- {
- get
- {
- string temp;
- if (GetProperty(Actor.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "HeightResizePolicy get error!");
-#endif
- }
- switch (temp)
- {
- case "FIXED":
- return ResizePolicyType.Fixed;
- case "USE_NATURAL_SIZE":
- return ResizePolicyType.UseNaturalSize;
- case "FILL_TO_PARENT":
- return ResizePolicyType.FillToParent;
- case "SIZE_RELATIVE_TO_PARENT":
- return ResizePolicyType.SizeRelativeToParent;
- case "SIZE_FIXED_OFFSET_FROM_PARENT":
- return ResizePolicyType.SizeFixedOffsetFromParent;
- case "FIT_TO_CHILDREN":
- return ResizePolicyType.FitToChildren;
- case "DIMENSION_DEPENDENCY":
- return ResizePolicyType.DimensionDependency;
- case "USE_ASSIGNED_SIZE":
- return ResizePolicyType.UseAssignedSize;
- default:
- return ResizePolicyType.Fixed;
- }
- }
- set
- {
- SetProperty(Actor.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the policy to use when setting size with size negotiation.<br>
- /// Defaults to SizeScalePolicyType.UseSizeSet.<br>
- /// </summary>
- public SizeScalePolicyType SizeScalePolicy
- {
- get
- {
- string temp;
- if (GetProperty(Actor.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "SizeScalePolicy get error!");
-#endif
- }
- switch (temp)
- {
- case "USE_SIZE_SET":
- return SizeScalePolicyType.UseSizeSet;
- case "FIT_WITH_ASPECT_RATIO":
- return SizeScalePolicyType.FitWithAspectRatio;
- case "FILL_WITH_ASPECT_RATIO":
- return SizeScalePolicyType.FillWithAspectRatio;
- default:
- return SizeScalePolicyType.UseSizeSet;
- }
- }
- set
- {
- string valueToString = "";
- switch (value)
- {
- case SizeScalePolicyType.UseSizeSet:
- {
- valueToString = "USE_SIZE_SET";
- break;
- }
- case SizeScalePolicyType.FitWithAspectRatio:
- {
- valueToString = "FIT_WITH_ASPECT_RATIO";
- break;
- }
- case SizeScalePolicyType.FillWithAspectRatio:
- {
- valueToString = "FILL_WITH_ASPECT_RATIO";
- break;
- }
- default:
- {
- valueToString = "USE_SIZE_SET";
- break;
- }
- }
- SetProperty(Actor.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
- }
- }
-
- /// <summary>
- /// Gets/Sets the status of whether the width size is dependent on height size.
- /// </summary>
- public bool WidthDependentOnHeight
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.WIDTH_FOR_HEIGHT).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the status of whether the height size is dependent on width size.
- /// </summary>
- public bool HeightDependentOnWidth
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.HEIGHT_FOR_WIDTH).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the padding for use in layout.
- /// </summary>
- public Vector4 Padding
- {
- get
- {
- Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
- GetProperty(Actor.Property.PADDING).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.PADDING, new Tizen.NUI.PropertyValue(value));
- }
- }
-
-
- /// <summary>
- /// Gets/Sets the minimum size an actor can be assigned in size negotiation.
- /// </summary>
- public Size2D MinimumSize
- {
- get
- {
- Size2D temp = new Size2D(0, 0);
- GetProperty(Actor.Property.MINIMUM_SIZE).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
-
- /// <summary>
- /// Gets/Sets the maximum size an actor can be assigned in size negotiation.
- /// </summary>
- public Size2D MaximumSize
- {
- get
- {
- Size2D temp = new Size2D(0, 0);
- GetProperty(Actor.Property.MAXIMUM_SIZE).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets whether a child actor inherits it's parent's position.<br>
- /// Default is to inherit.<br>
- /// Switching this off means that using Position sets the actor's world position, i.e. translates from the world origin(0,0,0) to the anchor point of the actor.<br>
- /// </summary>
- public bool InheritPosition
- {
- get
- {
- bool temp = false;
- GetProperty(Actor.Property.INHERIT_POSITION).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(Actor.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets clipping behavior(mode) of it's children.
- /// </summary>
- public ClippingModeType ClippingMode
- {
- get
- {
- string temp;
- if (GetProperty(Actor.Property.CLIPPING_MODE).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "ClippingMode get error!");
-#endif
- }
- switch (temp)
- {
- case "DISABLED":
- return ClippingModeType.Disabled;
- case "CLIP_CHILDREN":
- return ClippingModeType.ClipChildren;
- default:
- return ClippingModeType.Disabled;
- }
- }
- set
- {
- SetProperty(Actor.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
- }
- }
- }
-}
/// </summary>
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
using System;
using System.Runtime.InteropServices;
+ using Tizen.NUI.BaseComponents;
/// <summary>
- /// Animation can be used to animate the properties of any number of objects, typically Actors.<br>
+ /// Animation can be used to animate the properties of any number of objects, typically View.<br>
/// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.<br>
/// This is typically done in the object destructor, and requires either the Animation handle to be stored.<br>
/// The overall animation time is superseded by the values given in the animation time used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.<br>
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// <param name="property">The target property to animate</param>
/// <param name="relativeValue">The property value will change by this amount</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimateBy(Actor target, string property, object relativeValue, AlphaFunction alphaFunction = null)
+ public void AnimateBy(View target, string property, object relativeValue, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
string _str2 = property.Substring(1);
/// <param name="startTime">Start time of animation</param>
/// <param name="endTime">End time of animation</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimateBy(Actor target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
+ public void AnimateBy(View target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
string _str2 = property.Substring(1);
/// <param name="property">The target property to animate</param>
/// <param name="destinationValue">The destination value</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimateTo(Actor target, string property, object destinationValue, AlphaFunction alphaFunction = null)
+ public void AnimateTo(View target, string property, object destinationValue, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
string _str2 = property.Substring(1);
/// <param name="startTime">Start time of animation</param>
/// <param name="endTime">End time of animation</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimateTo(Actor target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
+ public void AnimateTo(View target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
string _str2 = property.Substring(1);
/// <param name="keyFrames">The set of time/value pairs between which to animate</param>
/// <param name="interpolation">The method used to interpolate between values</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimateBetween(Actor target, string property, KeyFrames keyFrames, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
+ public void AnimateBetween(View target, string property, KeyFrames keyFrames, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
string _str2 = property.Substring(1);
/// <param name="endTime">End time of animation in milli seconds</param>
/// <param name="interpolation">The method used to interpolate between values</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimateBetween(Actor target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
+ public void AnimateBetween(View target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
string _str2 = property.Substring(1);
}
/// <summary>
- /// Animates an actor's position and orientation through a predefined path.<br>
- /// The actor will rotate to orient the supplied forward vector with the path's tangent.<br>
+ /// Animates an view's position and orientation through a predefined path.<br>
+ /// The view will rotate to orient the supplied forward vector with the path's tangent.<br>
/// If forward is the zero vector then no rotation will happen.<br>
/// </summary>
- /// <param name="actor">The actor to animate</param>
+ /// <param name="view">The view to animate</param>
/// <param name="path">It defines position and orientation</param>
/// <param name="forward">The vector (in local space coordinate system) that will be oriented with the path's tangent direction</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimatePath(Actor actor, Path path, Vector3 forward, AlphaFunction alphaFunction = null)
+ public void AnimatePath(View view, Path path, Vector3 forward, AlphaFunction alphaFunction = null)
{
if (alphaFunction == null)
{
- Animate(actor, path, forward);
+ Animate(view, path, forward);
}
else
{
- Animate(actor, path, forward, alphaFunction);
+ Animate(view, path, forward, alphaFunction);
}
}
/// <summary>
- /// Animates an actor's position and orientation through a predefined path.<br>
- /// The actor will rotate to orient the supplied forward vector with the path's tangent.<br>
+ /// Animates an view's position and orientation through a predefined path.<br>
+ /// The view will rotate to orient the supplied forward vector with the path's tangent.<br>
/// If forward is the zero vector then no rotation will happen.<br>
/// </summary>
- /// <param name="actor">The actor to animate</param>
+ /// <param name="view">The view to animate</param>
/// <param name="path">It defines position and orientation</param>
/// <param name="forward">The vector (in local space coordinate system) that will be oriented with the path's tangent direction</param>
/// <param name="startTime">Start time of animation</param>
/// <param name="endTime">End time of animation</param>
/// <param name="alphaFunction">The alpha function to apply</param>
- public void AnimatePath(Actor actor, Path path, Vector3 forward, int startTime, int endTime, AlphaFunction alphaFunction = null)
+ public void AnimatePath(View view, Path path, Vector3 forward, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
TimePeriod time = new TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
if (alphaFunction == null)
{
- Animate(actor, path, forward, time);
+ Animate(view, path, forward, time);
}
else
{
- Animate(actor, path, forward, alphaFunction, time);
+ Animate(view, path, forward, alphaFunction, time);
}
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Animate(Actor actor, Path path, Vector3 forward)
+ internal void Animate(View view, Path path, Vector3 forward)
{
- NDalicPINVOKE.Animation_Animate__SWIG_0(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward));
+ NDalicPINVOKE.Animation_Animate__SWIG_0(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Animate(Actor actor, Path path, Vector3 forward, AlphaFunction alpha)
+ internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha)
{
- NDalicPINVOKE.Animation_Animate__SWIG_1(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
+ NDalicPINVOKE.Animation_Animate__SWIG_1(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Animate(Actor actor, Path path, Vector3 forward, TimePeriod period)
+ internal void Animate(View view, Path path, Vector3 forward, TimePeriod period)
{
- NDalicPINVOKE.Animation_Animate__SWIG_2(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
+ NDalicPINVOKE.Animation_Animate__SWIG_2(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Animate(Actor actor, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period)
+ internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period)
{
- NDalicPINVOKE.Animation_Animate__SWIG_3(swigCPtr, Actor.getCPtr(actor), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
+ NDalicPINVOKE.Animation_Animate__SWIG_3(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Show(Actor actor, float delaySeconds)
+ internal void Show(View view, float delaySeconds)
{
- NDalicPINVOKE.Animation_Show(swigCPtr, Actor.getCPtr(actor), delaySeconds);
+ NDalicPINVOKE.Animation_Show(swigCPtr, View.getCPtr(view), delaySeconds);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Hide(Actor actor, float delaySeconds)
+ internal void Hide(View view, float delaySeconds)
{
- NDalicPINVOKE.Animation_Hide(swigCPtr, Actor.getCPtr(actor), delaySeconds);
+ NDalicPINVOKE.Animation_Hide(swigCPtr, View.getCPtr(view), delaySeconds);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
// Set the StyleName the name of the View
// We have to do this because the StyleManager on Native side can't workout it out
- // This will also ensure that the style of actors/visuals initialized above are applied by the style manager.
+ // This will also ensure that the style of views/visuals initialized above are applied by the style manager.
SetStyleName(this.GetType().Name);
}
/// <summary>
/// Sets whether this control supports two dimensional keyboard navigation
- /// (i.e. whether it knows how to handle the keyboard focus movement between its child actors).<br>
+ /// (i.e. whether it knows how to handle the keyboard focus movement between its child views).<br>
/// The control doesn't support it by default.<br>
/// </summary>
/// <param name="isSupported">Whether this control supports two dimensional keyboard navigation.</param>
/// <summary>
/// Sets whether this control is a focus group for keyboard navigation.
- /// (i.e. the scope of keyboard focus movement can be limitied to its child actors). The control is not a focus group by default.
+ /// (i.e. the scope of keyboard focus movement can be limitied to its child views). The control is not a focus group by default.
/// </summary>
/// <param name="isFocusGroup">Whether this control is set as a focus group for keyboard navigation</param>
internal void SetAsKeyboardFocusGroup(bool isFocusGroup)
}
/// <summary>
- /// Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene).<br>
+ /// Request a relayout, which means performing a size negotiation on this view, its parent and children (and potentially whole scene).<br>
/// This method can also be called from a derived class every time it needs a different size.<br>
/// At the end of event processing, the relayout process starts and all controls which requested Relayout will have their sizes (re)negotiated.<br>
/// It can be called multiple times; the size negotiation is still only performed once, i.e. there is no need to keep track of this in the calling side.<br>
}
/// <summary>
- /// Provides the Actor implementation of GetHeightForWidth.
+ /// Provides the View implementation of GetHeightForWidth.
/// <summary>
/// <param name="width">Width to use</param>
/// <returns>The height based on the width</returns>
}
/// <summary>
- /// Provides the Actor implementation of GetWidthForHeight.
+ /// Provides the View implementation of GetWidthForHeight.
/// </summary>
/// <param name="height">Height to use</param>
/// <returns>The width based on the height</returns>
}
/// <summary>
- /// Calculate the size for a child using the base actor object.
+ /// Calculate the size for a child using the base view object.
/// </summary>
- /// <param name="child">The child actor to calculate the size for</param>
+ /// <param name="child">The child view to calculate the size for</param>
/// <param name="dimension">The dimension to calculate the size for. E.g. width or height</param>
/// <returns>Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found</returns>
- protected float CalculateChildSizeBase(Actor child, DimensionType dimension)
+ protected float CalculateChildSizeBase(View child, DimensionType dimension)
{
return viewWrapperImpl.CalculateChildSizeBase(child, dimension);
}
/// <summary>
- /// Determine if this actor is dependent on it's children for relayout from the base class.
+ /// Determine if this view is dependent on it's children for relayout from the base class.
/// </summary>
/// <param name="dimension">The dimension(s) to check for</param>
- /// <returns>Return if the actor is dependent on it's children</returns>
+ /// <returns>Return if the view is dependent on it's children</returns>
protected bool RelayoutDependentOnChildrenBase(DimensionType dimension)
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase(dimension);
}
/// <summary>
- /// Determine if this actor is dependent on it's children for relayout from the base class.
+ /// Determine if this view is dependent on it's children for relayout from the base class.
/// </summary>
- /// <returns>Return if the actor is dependent on it's children</returns>
+ /// <returns>Return if the view is dependent on it's children</returns>
protected bool RelayoutDependentOnChildrenBase()
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase();
}
/// <summary>
- /// Register a visual by Property Index, linking an Actor to visual when required.<br>
- /// In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle.<br>
+ /// Register a visual by Property Index, linking an View to visual when required.<br>
+ /// In the case of the visual being an view or control deeming visual not required then visual should be an empty handle.<br>
/// No parenting is done during registration, this should be done by derived class.<br>
/// </summary>
/// <param name="index">The Property index of the visual, used to reference visual</param>
}
/// <summary>
- /// Register a visual by Property Index, linking an Actor to visual when required.<br>
- /// In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle.<br>
+ /// Register a visual by Property Index, linking an View to visual when required.<br>
+ /// In the case of the visual being an view or control deeming visual not required then visual should be an empty handle.<br>
/// If enabled is false then the visual is not set on stage until enabled by the derived class.<br>
/// </summary>
/// <param name="index">The Property index of the visual, used to reference visual</param>
}
/// <summary>
- /// Called after the actor has been connected to the stage.<br>
- /// When an actor is connected, it will be directly or indirectly parented to the root Actor.<br>
- /// The root Actor is provided automatically by Tizen.NUI.Stage, and is always considered to be connected.<br>
- /// When the parent of a set of actors is connected to the stage, then all of the children will received this callback.<br>
+ /// Called after the view has been connected to the stage.<br>
+ /// When an view is connected, it will be directly or indirectly parented to the root View.<br>
+ /// The root View is provided automatically by Tizen.NUI.Stage, and is always considered to be connected.<br>
+ /// When the parent of a set of views is connected to the stage, then all of the children will received this callback.<br>
/// </summary>
- /// <param name="depth">The depth in the hierarchy for the actor</param>
+ /// <param name="depth">The depth in the hierarchy for the view</param>
public virtual void OnStageConnection(int depth)
{
}
/// <summary>
- /// Called after the actor has been disconnected from Stage.<br>
- /// If an actor is disconnected it either has no parent, or is parented to a disconnected actor.<br>
- /// When the parent of a set of actors is disconnected to the stage, then all of the children will received this callback, starting with the leaf actors.<br>
+ /// Called after the view has been disconnected from Stage.<br>
+ /// If an view is disconnected it either has no parent, or is parented to a disconnected view.<br>
+ /// When the parent of a set of views is disconnected to the stage, then all of the children will received this callback, starting with the leaf views.<br>
/// </summary>
public virtual void OnStageDisconnection()
{
}
/// <summary>
- /// Called after a child has been added to the owning actor.
+ /// Called after a child has been added to the owning view.
/// </summary>
- /// <param name="actor">The child which has been added</param>
- public virtual void OnChildAdd(Actor actor)
+ /// <param name="view">The child which has been added</param>
+ public virtual void OnChildAdd(View view)
{
}
/// <summary>
- /// Called after the owning actor has attempted to remove a child( regardless of whether it succeeded or not ).
+ /// Called after the owning view has attempted to remove a child( regardless of whether it succeeded or not ).
/// </summary>
- /// <param name="actor">The child being removed</param>
- public virtual void OnChildRemove(Actor actor)
+ /// <param name="view">The child being removed</param>
+ public virtual void OnChildRemove(View view)
{
}
/// <summary>
- /// Called when the owning actor property is set.
+ /// Called when the owning view property is set.
/// </summary>
/// <param name="index">The Property index that was set</param>
/// <param name="propertyValue">The value to set</param>
}
/// <summary>
- /// Called when the owning actor's size is set e.g. using Actor.SetSize().
+ /// Called when the owning view's size is set e.g. using View.SetSize().
/// </summary>
- /// <param name="targetSize">The target size. Note that this target size may not match the size returned via Actor.GetTargetSize</param>
+ /// <param name="targetSize">The target size. Note that this target size may not match the size returned via View.GetTargetSize</param>
public virtual void OnSizeSet(Vector3 targetSize)
{
}
/// <summary>
- /// Called when the owning actor's size is animated e.g. using Animation::AnimateTo( Property( actor, Actor::Property::SIZE ), ... ).
+ /// Called when the owning view's size is animated e.g. using Animation::AnimateTo( Property( view, View::Property::SIZE ), ... ).
/// </summary>
- /// <param name="animation">The object which is animating the owning actor</param>
- /// <param name="targetSize">The target size. Note that this target size may not match the size returned via @ref Actor.GetTargetSize</param>
+ /// <param name="animation">The object which is animating the owning view</param>
+ /// <param name="targetSize">The target size. Note that this target size may not match the size returned via @ref View.GetTargetSize</param>
public virtual void OnSizeAnimation(Animation animation, Vector3 targetSize)
{
}
/// <summary>
- /// Called after a touch-event is received by the owning actor.<br>
+ /// Called after a touch-event is received by the owning view.<br>
/// CustomViewBehaviour.REQUIRES_TOUCH_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br>
/// </summary>
/// <param name="touch">The touch event</param>
}
/// <summary>
- /// Called after a hover-event is received by the owning actor.<br>
+ /// Called after a hover-event is received by the owning view.<br>
/// CustomViewBehaviour.REQUIRES_HOVER_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br>
/// </summary>
/// <param name="hover">The hover event</param>
}
/// <summary>
- /// Called after a key-event is received by the actor that has had its focus set.
+ /// Called after a key-event is received by the view that has had its focus set.
/// </summary>
/// <param name="key">The key event</param>
/// <returns>True if the key event should be consumed</returns>
}
/// <summary>
- /// Called after a wheel-event is received by the owning actor.<br>
+ /// Called after a wheel-event is received by the owning view.<br>
/// CustomViewBehaviour.REQUIRES_WHEEL_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br>
/// </summary>
/// <param name="wheel">The wheel event</param>
/// <summary>
/// Called after the size negotiation has been finished for this control.<br>
/// The control is expected to assign this given size to itself/its children.<br>
- /// Should be overridden by derived classes if they need to layout actors differently after certain operations like add or remove actors, resize or after changing specific properties.<br>
+ /// Should be overridden by derived classes if they need to layout views differently after certain operations like add or remove views, resize or after changing specific properties.<br>
/// As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored).<br>
/// </summary>
/// <param name="size">The allocated size</param>
- /// <param name="container">The control should add actors to this container that it is not able to allocate a size for</param>
+ /// <param name="container">The control should add views to this container that it is not able to allocate a size for</param>
public virtual void OnRelayout(Vector2 size, RelayoutContainer container)
{
}
}
/// <summary>
- /// Return the natural size of the actor.
+ /// Return the natural size of the view.
/// </summary>
- /// <returns>The actor's natural size</returns>
+ /// <returns>The view's natural size</returns>
public virtual Size GetNaturalSize()
{
return new Size(0.0f, 0.0f, 0.0f);
/// <summary>
/// Calculate the size for a child.
/// </summary>
- /// <param name="child">The child actor to calculate the size for</param>
+ /// <param name="child">The child view to calculate the size for</param>
/// <param name="dimension">The dimension to calculate the size for. E.g. width or height</param>
/// <returns>Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found.</returns>
- public virtual float CalculateChildSize(Actor child, DimensionType dimension)
+ public virtual float CalculateChildSize(View child, DimensionType dimension)
{
return viewWrapperImpl.CalculateChildSizeBase(child, dimension);
}
}
/// <summary>
- /// Determine if this actor is dependent on it's children for relayout.
+ /// Determine if this view is dependent on it's children for relayout.
/// </summary>
/// <param name="dimension">The dimension(s) to check for</param>
- /// <returns>Return if the actor is dependent on it's children</returns>
+ /// <returns>Return if the view is dependent on it's children</returns>
public virtual bool RelayoutDependentOnChildren(DimensionType dimension)
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase(dimension);
}
/// <summary>
- /// Determine if this actor is dependent on it's children for relayout from the base class.
+ /// Determine if this view is dependent on it's children for relayout from the base class.
/// </summary>
- /// <returns>Return true if the actor is dependent on it's children</returns>
+ /// <returns>Return true if the view is dependent on it's children</returns>
public virtual bool RelayoutDependentOnChildren()
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase();
}
/// <summary>
- /// Gets the next keyboard focusable actor in this control towards the given direction.<br>
+ /// Gets the next keyboard focusable view in this control towards the given direction.<br>
/// A control needs to override this function in order to support two dimensional keyboard navigation.<br>
/// </summary>
- /// <param name="currentFocusedView">The current focused actor</param>
+ /// <param name="currentFocusedView">The current focused view</param>
/// <param name="direction">The direction to move the focus towards</param>
/// <param name="loopEnabled">Whether the focus movement should be looped within the control</param>
- /// <returns>the next keyboard focusable actor in this control or an empty handle if no actor can be focused</returns>
+ /// <returns>the next keyboard focusable view in this control or an empty handle if no view can be focused</returns>
public virtual View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled)
{
return new View();
}
/// <summary>
- /// Informs this control that its chosen focusable actor will be focused.<br>
- /// This allows the application to preform any actions if wishes before the focus is actually moved to the chosen actor.<br>
+ /// Informs this control that its chosen focusable view will be focused.<br>
+ /// This allows the application to preform any actions if wishes before the focus is actually moved to the chosen view.<br>
/// </summary>
- /// <param name="commitedFocusableView">The commited focused actor</param>
+ /// <param name="commitedFocusableView">The commited focused view</param>
public virtual void OnFocusChangeCommitted(View commitedFocusableView)
{
}
{
}
- private void OnControlChildAdd(Actor child)
+ private void OnControlChildAdd(View child)
{
}
- private void OnControlChildRemove(Actor child)
+ private void OnControlChildRemove(View child)
{
}
}
namespace Tizen.NUI.BaseComponents
{
+ using System;
+ using System.Runtime.InteropServices;
/// <summary>
/// ImageView is a class for displaying an image resource.<br>
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
+
+ /// <summary>
+ /// Event arguments of resource ready.
+ /// </summary>
+ public class ResourceReadyEventArgs : EventArgs
+ {
+ private View _view;
+
+ /// <summary>
+ /// The view whose resource is ready.
+ /// </summary>
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+ }
+
+ private EventHandler<ResourceReadyEventArgs> _resourceReadyEventHandler;
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void ResourceReadyEventCallbackType(IntPtr data);
+ private ResourceReadyEventCallbackType _resourceReadyEventCallback;
+
+ /// <summary>
+ /// Event for ResourceReady signal which can be used to subscribe/unsubscribe the event handler.<br>
+ /// This signal is emitted after all resources required by a control are loaded and ready.<br>
+ /// Most resources are only loaded when the control is placed on stage.<br>
+ /// </summary>
+ public event EventHandler<ResourceReadyEventArgs> ResourceReady
+ {
+ add
+ {
+ if (_resourceReadyEventHandler == null)
+ {
+ _resourceReadyEventCallback = OnResourceReady;
+ ResourceReadySignal(this).Connect(_resourceReadyEventCallback);
+ }
+
+ _resourceReadyEventHandler += value;
+ }
+
+ remove
+ {
+ _resourceReadyEventHandler -= value;
+
+ if (_resourceReadyEventHandler == null && ResourceReadySignal(this).Empty() == false)
+ {
+ ResourceReadySignal(this).Disconnect(_resourceReadyEventCallback);
+ }
+ }
+ }
+
+ // Callback for View ResourceReady signal
+ private void OnResourceReady(IntPtr data)
+ {
+ ResourceReadyEventArgs e = new ResourceReadyEventArgs();
+ if(data != null)
+ {
+ e.View = View.GetViewFromPtr(data);
+ }
+
+ if (_resourceReadyEventHandler != null)
+ {
+ _resourceReadyEventHandler(this, e);
+ }
+ }
+
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
}
}
-
internal class Property : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
ANIMATABLE_PROPERTY_END_INDEX = PropertyRanges.ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1000
}
+
+ internal ViewResourceReadySignal ResourceReadySignal(View view) {
+ ViewResourceReadySignal ret = new ViewResourceReadySignal(NDalicPINVOKE.ResourceReadySignal(View.getCPtr(view)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Query if all resources required by a control are loaded and ready.<br>
+ /// Most resources are only loaded when the control is placed on stage.<br>
+ /// true if the resources are loaded and ready, false otherwise.<br>
+ /// </summary>
+ public bool IsResourceReady()
+ {
+ bool ret = NDalicPINVOKE.IsResourceReady(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
/// <summary>
/// ImageView ResourceUrl, type string
/// </summary>
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~InputStyle()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~InputStyle()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// <summary>
/// View is the base class for all views.
/// </summary>
- public class View : CustomActor
+ public class View : Animatable //CustomActor => Animatable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
~View()
{
- //DisposeQueue.Instance.Add(this);
+ DisposeQueue.Instance.Add(this);
// Unregister this instance of view from the view registry.
ViewRegistry.UnregisterView(this);
}
- public override void Dispose()
+ public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())//Stage=>Window
{
DisposeQueue.Instance.Add(this);
return;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
- base.Dispose();
+ //base.Dispose();
}
}
}
- private EventHandler _onStageEventHandler;
+ private EventHandler _onWindowEventHandler;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OnStageEventCallbackType(IntPtr control);
- private OnStageEventCallbackType _onStageEventCallback;
+ private delegate void OnWindowEventCallbackType(IntPtr control);
+ private OnWindowEventCallbackType _onWindowEventCallback;
/// <summary>
- /// Event for OnStage signal which can be used to subscribe/unsubscribe the event handler.<br>
- /// OnStage signal is emitted after the view has been connected to the stage.<br>
+ /// Event for OnWindow signal which can be used to subscribe/unsubscribe the event handler.<br>
+ /// OnWindow signal is emitted after the view has been connected to the Window.<br>
/// </summary>
- public event EventHandler OnStageEvent
+ public event EventHandler OnWindowEvent
{
add
{
- if (_onStageEventHandler == null)
+ if (_onWindowEventHandler == null)
{
- _onStageEventCallback = OnStage;
- this.OnStageSignal().Connect(_onStageEventCallback);
+ _onWindowEventCallback = OnWindow;
+ this.OnWindowSignal().Connect(_onWindowEventCallback);
}
- _onStageEventHandler += value;
+ _onWindowEventHandler += value;
}
remove
{
- _onStageEventHandler -= value;
+ _onWindowEventHandler -= value;
- if (_onStageEventHandler == null && OnStageSignal().Empty() == false)
+ if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
{
- this.OnStageSignal().Disconnect(_onStageEventCallback);
+ this.OnWindowSignal().Disconnect(_onWindowEventCallback);
}
}
}
- // Callback for View OnStage signal
- private void OnStage(IntPtr data)
+ // Callback for View OnWindow signal
+ private void OnWindow(IntPtr data)
{
- if (_onStageEventHandler != null)
+ if (_onWindowEventHandler != null)
{
- _onStageEventHandler(this, null);
+ _onWindowEventHandler(this, null);
}
}
- private EventHandler _offStageEventHandler;
+ private EventHandler _offWindowEventHandler;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
- private delegate void OffStageEventCallbackType(IntPtr control);
- private OffStageEventCallbackType _offStageEventCallback;
+ private delegate void OffWindowEventCallbackType(IntPtr control);
+ private OffWindowEventCallbackType _offWindowEventCallback;
/// <summary>
- /// Event for OffStage signal which can be used to subscribe/unsubscribe the event handler.<br>
- /// OffStage signal is emitted after the view has been disconnected from the stage.<br>
+ /// Event for OffWindow signal which can be used to subscribe/unsubscribe the event handler.<br>
+ /// OffWindow signal is emitted after the view has been disconnected from the Window.<br>
/// </summary>
- public event EventHandler OffStageEvent
+ public event EventHandler OffWindowEvent
{
add
{
- if (_offStageEventHandler == null)
+ if (_offWindowEventHandler == null)
{
- _offStageEventCallback = OffStage;
- this.OffStageSignal().Connect(_offStageEventCallback);
+ _offWindowEventCallback = OffWindow;
+ this.OffWindowSignal().Connect(_offWindowEventCallback);
}
- _offStageEventHandler += value;
+ _offWindowEventHandler += value;
}
remove
{
- _offStageEventHandler -= value;
+ _offWindowEventHandler -= value;
- if (_offStageEventHandler == null && OffStageSignal().Empty() == false)
+ if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
{
- this.OffStageSignal().Disconnect(_offStageEventCallback);
+ this.OffWindowSignal().Disconnect(_offWindowEventCallback);
}
}
}
- // Callback for View OffStage signal
- private void OffStage(IntPtr data)
+ // Callback for View OffWindow signal
+ private void OffWindow(IntPtr data)
{
- if (_offStageEventHandler != null)
+ if (_offWindowEventHandler != null)
{
- _offStageEventHandler(this, null);
+ _offWindowEventHandler(this, null);
}
}
+ /// <summary>
+ /// Event arguments of visibility changed.
+ /// </summary>
+ public class VisibilityChangedEventArgs : EventArgs
+ {
+ private View _view;
+ private bool _visibility;
+ private VisibilityChangeType _type;
+
+ /// <summary>
+ /// The view, or child of view, whose visibility has changed.
+ /// </summary>
+ public View View
+ {
+ get
+ {
+ return _view;
+ }
+ set
+ {
+ _view = value;
+ }
+ }
+
+ /// <summary>
+ /// Whether the view is now visible or not.
+ /// </summary>
+ public bool Visibility
+ {
+ get
+ {
+ return _visibility;
+ }
+ set
+ {
+ _visibility = value;
+ }
+ }
+
+ /// <summary>
+ /// Whether the view's visible property has changed or a parent's.
+ /// </summary>
+ public VisibilityChangeType Type
+ {
+ get
+ {
+ return _type;
+ }
+ set
+ {
+ _type = value;
+ }
+ }
+ }
+
+ private EventHandler<VisibilityChangedEventArgs> _visibilityChangedEventHandler;
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
+ private VisibilityChangedEventCallbackType _visibilityChangedEventCallback;
+
+ /// <summary>
+ /// Event for visibility change which can be used to subscribe/unsubscribe the event handler.<br>
+ /// This signal is emitted when the visible property of this or a parent view is changed.<br>
+ /// </summary>
+ public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
+ {
+ add
+ {
+ if (_visibilityChangedEventHandler == null)
+ {
+ _visibilityChangedEventCallback = OnVisibilityChanged;
+ VisibilityChangedSignal(this).Connect(_visibilityChangedEventCallback);
+ }
+
+ _visibilityChangedEventHandler += value;
+ }
+ remove
+ {
+ _visibilityChangedEventHandler -= value;
+ if (_visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false)
+ {
+ VisibilityChangedSignal(this).Disconnect(_visibilityChangedEventCallback);
+ }
+ }
+ }
+ // Callback for View visibility change signal
+ private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
+ {
+ VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
+ if (data != null)
+ {
+ e.View = View.GetViewFromPtr(data);
+ }
+ e.Visibility = visibility;
+ e.Type = type;
+ if (_visibilityChangedEventHandler != null)
+ {
+ _visibilityChangedEventHandler(this, e);
+ }
+ }
internal static View GetViewFromPtr(global::System.IntPtr cPtr)
{
return ret;
}
+ internal IntPtr GetPtrfromView()
+ {
+ return (IntPtr)swigCPtr;
+ }
+
internal class Property : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
internal static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
internal static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
internal static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
- internal static readonly int LEFT_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
- internal static readonly int RIGHT_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
- internal static readonly int UP_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
- internal static readonly int DOWN_FOCUSABLE_ACTOR_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
+ internal static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
+ internal static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
+ internal static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
+ internal static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
internal Property() : this(NDalicPINVOKE.new_View_Property(), true)
{
internal static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();
internal static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
internal static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
-
+ internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
+ internal static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
+ internal static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
+ internal static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
+ internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
+ internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
+ internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
+ internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
+ internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
+ internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
+ internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
+ internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
+ internal static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
+ internal static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
+ internal static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
+ internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
+ internal static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
+ internal static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
+ internal static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
+ internal static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
+ internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
+ internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
+ internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
+ internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
+ internal static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
+ internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
+ internal static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
+ internal static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
+ internal static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
+ internal static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
+ internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
+ internal static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
+ internal static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
+ internal static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
+ internal static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
+ internal static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
+ internal static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
+ internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
+ internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
+ internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
+ internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
+ internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
+ internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
+ internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
+ internal static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
+ internal static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
+ internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
+ internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
+ internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
+ internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
+ internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
+ internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
+ internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
+ internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
+ internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
+ internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
+ internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
+ internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
}
/// Downcasts a handle to class which inherit View handle.
/// </summary>
/// <typeparam name="T">Class which inherit View</typeparam>
- /// <param name="actor">Actor to an object</param>
+ /// <param name="view">View to an object</param>
/// <returns>A object which inherit View</returns>
- public static T DownCast<T>(Actor actor) where T : View
+ public static T DownCast<T>(View view) where T : View
{
- return (T)(ViewRegistry.GetViewFromActor(actor));
+ return (T)(ViewRegistry.GetViewFromActor(view));
}
private View ConvertIdToView(uint id)
{
- Actor actor = null;
+ View view = null;
if (Parent)
{
- actor = Parent.FindChildById(id);
+ view = Parent.FindChildById(id);
}
- if (!actor)
+ if (!view)
{
- actor = Stage.Instance.GetRootLayer().FindChildById(id);
+ view = Window.Instance.GetRootLayer().FindChildById(id);
}
- return View.DownCast<View>(actor);
+ return view;
}
internal void SetKeyInputFocus()
}
}
- private int LeftFocusableActorId
+ private int LeftFocusableViewId
{
get
{
int temp = 0;
- GetProperty(View.Property.LEFT_FOCUSABLE_ACTOR_ID).Get(ref temp);
+ GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(ref temp);
return temp;
}
set
{
- SetProperty(View.Property.LEFT_FOCUSABLE_ACTOR_ID, new Tizen.NUI.PropertyValue(value));
+ SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
}
}
- private int RightFocusableActorId
+ private int RightFocusableViewId
{
get
{
int temp = 0;
- GetProperty(View.Property.RIGHT_FOCUSABLE_ACTOR_ID).Get(ref temp);
+ GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(ref temp);
return temp;
}
set
{
- SetProperty(View.Property.RIGHT_FOCUSABLE_ACTOR_ID, new Tizen.NUI.PropertyValue(value));
+ SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
}
}
- private int UpFocusableActorId
+ private int UpFocusableViewId
{
get
{
int temp = 0;
- GetProperty(View.Property.UP_FOCUSABLE_ACTOR_ID).Get(ref temp);
+ GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(ref temp);
return temp;
}
set
{
- SetProperty(View.Property.UP_FOCUSABLE_ACTOR_ID, new Tizen.NUI.PropertyValue(value));
+ SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
}
}
- private int DownFocusableActorId
+ private int DownFocusableViewId
{
get
{
int temp = 0;
- GetProperty(View.Property.DOWN_FOCUSABLE_ACTOR_ID).Get(ref temp);
+ GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(ref temp);
return temp;
}
set
{
- SetProperty(View.Property.DOWN_FOCUSABLE_ACTOR_ID, new Tizen.NUI.PropertyValue(value));
+ SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
}
}
/// <summary>
/// The left focusable view.<br>
/// This will return NULL if not set.<br>
- /// This will also return NULL if the specified left focusable view is not on stage.<br>
+ /// This will also return NULL if the specified left focusable view is not on Window.<br>
/// </summary>
public View LeftFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- if (LeftFocusableActorId >= 0)
+ if (LeftFocusableViewId >= 0)
{
- return ConvertIdToView((uint)LeftFocusableActorId);
+ return ConvertIdToView((uint)LeftFocusableViewId);
}
return null;
}
set
{
- LeftFocusableActorId = (int)value.GetId();
+ LeftFocusableViewId = (int)value.GetId();
}
}
/// <summary>
/// The right focusable view.<br>
/// This will return NULL if not set.<br>
- /// This will also return NULL if the specified right focusable view is not on stage.<br>
+ /// This will also return NULL if the specified right focusable view is not on Window.<br>
/// </summary>
public View RightFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- if (RightFocusableActorId >= 0)
+ if (RightFocusableViewId >= 0)
{
- return ConvertIdToView((uint)RightFocusableActorId);
+ return ConvertIdToView((uint)RightFocusableViewId);
}
return null;
}
set
{
- RightFocusableActorId = (int)value.GetId();
+ RightFocusableViewId = (int)value.GetId();
}
}
/// <summary>
/// The up focusable view.<br>
/// This will return NULL if not set.<br>
- /// This will also return NULL if the specified up focusable view is not on stage.<br>
+ /// This will also return NULL if the specified up focusable view is not on Window.<br>
/// </summary>
public View UpFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- if (UpFocusableActorId >= 0)
+ if (UpFocusableViewId >= 0)
{
- return ConvertIdToView((uint)UpFocusableActorId);
+ return ConvertIdToView((uint)UpFocusableViewId);
}
return null;
}
set
{
- UpFocusableActorId = (int)value.GetId();
+ UpFocusableViewId = (int)value.GetId();
}
}
/// <summary>
/// The down focusable view.<br>
/// This will return NULL if not set.<br>
- /// This will also return NULL if the specified down focusable view is not on stage.<br>
+ /// This will also return NULL if the specified down focusable view is not on Window.<br>
/// </summary>
public View DownFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
get
{
- if (DownFocusableActorId >= 0)
+ if (DownFocusableViewId >= 0)
{
- return ConvertIdToView((uint)DownFocusableActorId);
+ return ConvertIdToView((uint)DownFocusableViewId);
}
return null;
}
set
{
- DownFocusableActorId = (int)value.GetId();
+ DownFocusableViewId = (int)value.GetId();
}
}
/// </summary>
Disabled
}
+
+ /// <summary>
+ /// Retrieves the position of the View.<br>
+ /// The coordinates are relative to the View's parent.<br>
+ /// </summary>
+ public Position CurrentPosition
+ {
+ get
+ {
+ return GetCurrentPosition();
+ }
+ }
+
+ /// <summary>
+ /// Sets the size of an view for width and height.<br>
+ /// Geometry can be scaled to fit within this area.<br>
+ /// This does not interfere with the views scale factor.<br>
+ /// The views default depth is the minimum of width & height.<br>
+ /// </summary>
+ public Size2D Size2D
+ {
+ get
+ {
+ Size temp = new Size(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE).Get(temp);
+ return new Size2D(temp);
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size(value)));
+ }
+ }
+
+ /// <summary>
+ /// Retrieves the size of the View.<br>
+ /// The coordinates are relative to the View's parent.<br>
+ /// </summary>
+ public Size CurrentSize
+ {
+ get
+ {
+ return GetCurrentSize();
+ }
+ }
+
+ /// <summary>
+ /// Retrieves the view's parent.<br>
+ /// </summary>
+ public View Parent
+ {
+ get
+ {
+ return GetParent();
+ }
+ }
+
+ public bool Visibility
+ {
+ get
+ {
+ return IsVisible();
+ }
+ }
+
+ /// <summary>
+ /// Retrieves and sets the view's opacity.<br>
+ /// </summary>
+ public float Opacity
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.OPACITY).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.OPACITY, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Sets the position of the View for X and Y.<br>
+ /// By default, sets the position vector between the parent origin and anchor point(default).<br>
+ /// If Position inheritance if disabled, sets the world position.<br>
+ /// </summary>
+ public Position2D Position2D
+ {
+ get
+ {
+ Position temp = new Position(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.POSITION).Get(temp);
+ return new Position2D(temp);
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position(value)));
+ }
+ }
+
+ /// <summary>
+ /// Retrieves screen postion of view's.<br>
+ /// </summary>
+ public Vector2 ScreenPosition
+ {
+ get
+ {
+ Vector2 temp = new Vector2(0.0f, 0.0f);
+ GetProperty(View.Property.SCREEN_POSITION).Get(temp);
+ return temp;
+ }
+ }
+
+ /// <summary>
+ /// Determines whether the anchor point should be used to determine the position of the view.
+ /// This is true by default.
+ /// </summary>
+ /// <remarks>If false, then the top-left of the view is used for the position.
+ /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the view's position.
+ /// </remarks>
+ public bool PositionUsesAnchorPoint
+ {
+ get
+ {
+ bool temp = false;
+ if(this) GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ if(this) SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ public bool StateFocusEnable
+ {
+ get
+ {
+ return IsKeyboardFocusable();
+ }
+ set
+ {
+ SetKeyboardFocusable(value);
+ }
+ }
+
+ /// <summary>
+ /// Queries whether the view is connected to the Stage.<br>
+ /// When an view is connected, it will be directly or indirectly parented to the root View.<br>
+ /// </summary>
+ public bool IsOnWindow
+ {
+ get
+ {
+ return OnWindow();
+ }
+ }
+
+ /// <summary>
+ /// Gets depth in the hierarchy for the view.
+ /// </summary>
+ public int HierarchyDepth
+ {
+ get
+ {
+ return GetHierarchyDepth();
+ }
+ }
+
+ /// <summary>
+ /// Sets the sibling order of the view so depth position can be defined within the same parent.
+ /// </summary>
+ /// <remarks>
+ /// Note The initial value is 0.
+ /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.
+ /// The values set by this Property will likely change.
+ /// </remarks>
+ public int SiblingOrder
+ {
+ get
+ {
+ int temp = 0;
+ GetProperty(View.Property.SIBLING_ORDER).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Shows the View.
+ /// </summary>
+ /// <remarks>
+ /// This is an asynchronous method.
+ /// </remarks>
+ public void Show()
+ {
+ SetVisible(true);
+ }
+
+ /// <summary>
+ /// Hides the View.
+ /// </summary>
+ /// <remarks>
+ /// This is an asynchronous method.
+ /// If an view is hidden, then the view and its children will not be rendered.
+ /// This is regardless of the individual visibility of the children i.e.an view will only be rendered if all of its parents are shown.
+ /// </remarks>
+ public void Hide()
+ {
+ SetVisible(false);
+ }
+
+ /// <summary>
+ /// Raise view above the next highest level of view(s).
+ /// </summary>
+ /// <remarks>
+ /// Sibling order of views within the parent will be updated automatically.
+ /// Initially views added to a parent will have the same sibling order and shown in relation to insertion order.
+ /// Raising this view above views with the same sibling order as each other will raise this view above them.
+ /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
+ /// </remarks>
+ public void Raise()
+ {
+ NDalicPINVOKE.Raise(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Lower the view to underneath the level below view(s).
+ /// </summary>
+ /// <remarks>
+ /// Sibling order of views within the parent will be updated automatically.
+ /// Lowering this view below views with the same sibling order as each other will lower this view above them.
+ /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
+ /// </remarks>
+ public void Lower()
+ {
+ NDalicPINVOKE.Lower(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Raise view above all other views.
+ /// </summary>
+ /// <remarks>
+ /// Sibling order of views within the parent will be updated automatically.
+ /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
+ /// </remarks>
+ public void RaiseToTop()
+ {
+ NDalicPINVOKE.RaiseToTop(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Lower view to the bottom of all views.
+ /// </summary>
+ /// <remarks>
+ /// Sibling order of views within the parent will be updated automatically.
+ /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
+ /// </remarks>
+ public void LowerToBottom()
+ {
+ NDalicPINVOKE.LowerToBottom(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Raise the view to above the target view.
+ /// </summary>
+ /// <remarks>Sibling order of views within the parent will be updated automatically.
+ /// Views on the level above the target view will still be shown above this view.
+ /// Raising this view above views with the same sibling order as each other will raise this view above them.
+ /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
+ /// </remarks>
+ /// <param name="target">Will be raised above this view</param>
+ internal void RaiseAbove(View target)
+ {
+ NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Lower the view to below the target view.
+ /// </summary>
+ /// <remarks>Sibling order of views within the parent will be updated automatically.
+ /// Lowering this view below views with the same sibling order as each other will lower this view above them.
+ /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
+ /// </remarks>
+ /// <param name="target">Will be lowered below this view</param>
+ internal void LowerBelow(View target)
+ {
+ NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal string GetName()
+ {
+ string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetName(string name)
+ {
+ NDalicPINVOKE.Actor_SetName(swigCPtr, name);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal uint GetId()
+ {
+ uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal bool IsRoot()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal bool OnWindow()
+ {
+ bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal bool IsLayer()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Layer GetLayer()
+ {
+ Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Adds a child view to this View.
+ /// </summary>
+ /// <pre>This View(the parent) has been initialized. The child view has been initialized. The child view is not the same as the parent view.</pre>
+ /// <post>The child will be referenced by its parent. This means that the child will be kept alive, even if the handle passed into this method is reset or destroyed.</post>
+ /// <remarks>If the child already has a parent, it will be removed from old parent and reparented to this view. This may change child's position, color, scale etc as it now inherits them from this view.</remarks>
+ /// <param name="child">The child</param>
+ public void Add(View child)
+ {
+ NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Removes a child View from this View. If the view was not a child of this view, this is a no-op.
+ /// </summary>
+ /// <pre>This View(the parent) has been initialized. The child view is not the same as the parent view.</pre>
+ /// <param name="child">The child</param>
+ public void Remove(View child)
+ {
+ NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void Unparent()
+ {
+ NDalicPINVOKE.Actor_Unparent(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Retrieves the number of children held by the view.
+ /// </summary>
+ /// <pre>The View has been initialized.</pre>
+ /// <returns>The number of children</returns>
+ public uint GetChildCount()
+ {
+ uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Retrieves child view by index.
+ /// </summary>
+ /// <pre>The View has been initialized.</pre>
+ /// <param name="index">The index of the child to retrieve</param>
+ /// <returns>The view for the given index or empty handle if children not initialized</returns>
+ public View GetChildAt(uint index)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Search through this view's hierarchy for an view with the given name.
+ /// The view itself is also considered in the search.
+ /// </summary>
+ /// <pre>The View has been initialized.</pre>
+ /// <param name="viewName">The name of the view to find</param>
+ /// <returns>A handle to the view if found, or an empty handle if not</returns>
+ public View FindChildByName(string viewName)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, viewName), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal View FindChildById(uint id)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal View GetParent()
+ {
+ View ret = new View(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetParentOrigin(Vector3 origin)
+ {
+ NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector3 GetCurrentParentOrigin()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetAnchorPoint(Vector3 anchorPoint)
+ {
+ NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector3 GetCurrentAnchorPoint()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetSize(float width, float height)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetSize(float width, float height, float depth)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetSize(Vector2 size)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetSize(Vector3 size)
+ {
+ NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector3 GetTargetSize()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Size GetCurrentSize()
+ {
+ Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Returns the natural size of the view.<br>
+ /// Deriving classes stipulate the natural size and by default an view has a ZERO natural size.<br>
+ /// </summary>
+ /// <returns>The view's natural size</returns>
+ public Vector3 GetNaturalSize()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetPosition(float x, float y)
+ {
+ NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetPosition(float x, float y, float z)
+ {
+ NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetPosition(Vector3 position)
+ {
+ NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetX(float x)
+ {
+ NDalicPINVOKE.Actor_SetX(swigCPtr, x);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetY(float y)
+ {
+ NDalicPINVOKE.Actor_SetY(swigCPtr, y);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetZ(float z)
+ {
+ NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void TranslateBy(Vector3 distance)
+ {
+ NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Position GetCurrentPosition()
+ {
+ Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Vector3 GetCurrentWorldPosition()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetInheritPosition(bool inherit)
+ {
+ NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal PositionInheritanceMode GetPositionInheritanceMode()
+ {
+ PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal bool IsPositionInherited()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetOrientation(Degree angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetOrientation(Radian angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetOrientation(Rotation orientation)
+ {
+ NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void RotateBy(Degree angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void RotateBy(Radian angle, Vector3 axis)
+ {
+ NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void RotateBy(Rotation relativeRotation)
+ {
+ NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Rotation GetCurrentOrientation()
+ {
+ Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetInheritOrientation(bool inherit)
+ {
+ NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool IsOrientationInherited()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Rotation GetCurrentWorldOrientation()
+ {
+ Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetScale(float scale)
+ {
+ NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetScale(float scaleX, float scaleY, float scaleZ)
+ {
+ NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetScale(Vector3 scale)
+ {
+ NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void ScaleBy(Vector3 relativeScale)
+ {
+ NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector3 GetCurrentScale()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Vector3 GetCurrentWorldScale()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetInheritScale(bool inherit)
+ {
+ NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool IsScaleInherited()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Matrix GetCurrentWorldMatrix()
+ {
+ Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetVisible(bool visible)
+ {
+ NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool IsVisible()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetOpacity(float opacity)
+ {
+ NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal float GetCurrentOpacity()
+ {
+ float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetColor(Vector4 color)
+ {
+ NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector4 GetCurrentColor()
+ {
+ Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetColorMode(ColorMode colorMode)
+ {
+ NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal ColorMode GetColorMode()
+ {
+ ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Vector4 GetCurrentWorldColor()
+ {
+ Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetDrawMode(DrawModeType drawMode)
+ {
+ NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal DrawModeType GetDrawMode()
+ {
+ DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetSensitive(bool sensitive)
+ {
+ NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool IsSensitive()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Converts screen coordinates into the view's coordinate system using the default camera.
+ /// </summary>
+ /// <pre>The View has been initialized.</pre>
+ /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5)</remarks>
+ /// <param name="localX">On return, the X-coordinate relative to the view</param>
+ /// <param name="localY">On return, the Y-coordinate relative to the view</param>
+ /// <param name="screenX">The screen X-coordinate</param>
+ /// <param name="screenY">The screen Y-coordinate</param>
+ /// <returns>True if the conversion succeeded</returns>
+ public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
+ {
+ bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetLeaveRequired(bool required)
+ {
+ NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool GetLeaveRequired()
+ {
+ bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetKeyboardFocusable(bool focusable)
+ {
+ NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal bool IsKeyboardFocusable()
+ {
+ bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
+ {
+ NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal ResizePolicyType GetResizePolicy(DimensionType dimension)
+ {
+ ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetSizeScalePolicy(SizeScalePolicyType policy)
+ {
+ NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal SizeScalePolicyType GetSizeScalePolicy()
+ {
+ SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Sets the relative to parent size factor of the view.<br>
+ /// This factor is only used when ResizePolicy is set to either:
+ /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br>
+ /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br>
+ /// </summary>
+ /// <pre>The View has been initialized.</pre>
+ /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
+ public void SetSizeModeFactor(Vector3 factor)
+ {
+ NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector3 GetSizeModeFactor()
+ {
+ Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Calculates the height of the view given a width.<br>
+ /// The natural size is used for default calculation. <br>
+ /// size 0 is treated as aspect ratio 1:1.<br>
+ /// </summary>
+ /// <param name="width">Width to use</param>
+ /// <returns>The height based on the width</returns>
+ public float GetHeightForWidth(float width)
+ {
+ float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Calculates the width of the view given a height.<br>
+ /// The natural size is used for default calculation.<br>
+ /// size 0 is treated as aspect ratio 1:1.<br>
+ /// </summary>
+ /// <param name="height">Height to use</param>
+ /// <returns>The width based on the height</returns>
+ public float GetWidthForHeight(float height)
+ {
+ float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public float GetRelayoutSize(DimensionType dimension)
+ {
+ float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void SetPadding(PaddingType padding)
+ {
+ NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void GetPadding(PaddingType paddingOut)
+ {
+ NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void SetMinimumSize(Vector2 size)
+ {
+ NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector2 GetMinimumSize()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetMaximumSize(Vector2 size)
+ {
+ NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector2 GetMaximumSize()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal int GetHierarchyDepth()
+ {
+ int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal uint AddRenderer(Renderer renderer)
+ {
+ uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal uint GetRendererCount()
+ {
+ uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Renderer GetRendererAt(uint index)
+ {
+ Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void RemoveRenderer(Renderer renderer)
+ {
+ NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void RemoveRenderer(uint index)
+ {
+ NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal TouchDataSignal TouchSignal()
+ {
+ TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal HoverSignal HoveredSignal()
+ {
+ HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal WheelSignal WheelEventSignal()
+ {
+ WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal ViewSignal OnWindowSignal()
+ {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal ViewSignal OffWindowSignal()
+ {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal ViewSignal OnRelayoutSignal()
+ {
+ ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view) {
+ ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Gets/Sets the origin of an view, within its parent's area.<br>
+ /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.<br>
+ /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br>
+ /// An view's position is the distance between this origin, and the view's anchor-point.<br>
+ /// </summary>
+ /// <pre>The View has been initialized.</pre>
+ public Position ParentOrigin
+ {
+ get
+ {
+ Position temp = new Position(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ internal float ParentOriginX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.PARENT_ORIGIN_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ internal float ParentOriginY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.PARENT_ORIGIN_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ internal float ParentOriginZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.PARENT_ORIGIN_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the anchor-point of an view.<br>
+ /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the view, and (1.0, 1.0, 0.5) is the bottom-right corner.<br>
+ /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).<br>
+ /// An view position is the distance between its parent-origin and this anchor-point.<br>
+ /// An view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br>
+ /// <pre>The View has been initialized.</pre>
+ /// </summary>
+ public Position AnchorPoint
+ {
+ get
+ {
+ Position temp = new Position(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.ANCHOR_POINT).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ internal float AnchorPointX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.ANCHOR_POINT_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ internal float AnchorPointY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.ANCHOR_POINT_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ internal float AnchorPointZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.ANCHOR_POINT_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the size of an view.<br>
+ /// Geometry can be scaled to fit within this area.<br>
+ /// This does not interfere with the views scale factor.<br>
+ /// </summary>
+ public Size Size
+ {
+ get
+ {
+ Size temp = new Size(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the size width of an view.
+ /// </summary>
+ public float SizeWidth
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SIZE_WIDTH).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the size height of an view.
+ /// </summary>
+ public float SizeHeight
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SIZE_HEIGHT).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the size depth of an view.
+ /// </summary>
+ public float SizeDepth
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SIZE_DEPTH).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the position of the View.<br>
+ /// By default, sets the position vector between the parent origin and anchor point(default).<br>
+ /// If Position inheritance if disabled, sets the world position.<br>
+ /// </summary>
+ public Position Position
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.POSITION).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the position x of the View.
+ /// </summary>
+ public float PositionX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.POSITION_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the position y of the View.
+ /// </summary>
+ public float PositionY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.POSITION_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the position z of the View.
+ /// </summary>
+ public float PositionZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.POSITION_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the world position of the View.
+ /// </summary>
+ public Vector3 WorldPosition
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.WORLD_POSITION).Get(temp);
+ return temp;
+ }
+ }
+
+ internal float WorldPositionX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.WORLD_POSITION_X).Get(ref temp);
+ return temp;
+ }
+ }
+
+ internal float WorldPositionY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.WORLD_POSITION_Y).Get(ref temp);
+ return temp;
+ }
+ }
+
+ internal float WorldPositionZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.WORLD_POSITION_Z).Get(ref temp);
+ return temp;
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the orientation of the View.<br>
+ /// An view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br>
+ /// </summary>
+ /// <remarks>This is an asynchronous method.</remarks>
+ public Rotation Orientation
+ {
+ get
+ {
+ Rotation temp = new Rotation();
+ GetProperty(View.Property.ORIENTATION).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the world orientation of the View.<br>
+ /// </summary>
+ public Rotation WorldOrientation
+ {
+ get
+ {
+ Rotation temp = new Rotation();
+ GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
+ return temp;
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the scale factor applied to an view.<br>
+ /// </summary>
+ public Vector3 Scale
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SCALE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the scale x factor applied to an view.
+ /// </summary>
+ public float ScaleX
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SCALE_X).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the scale y factor applied to an view.
+ /// </summary>
+ public float ScaleY
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SCALE_Y).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the scale z factor applied to an view.
+ /// </summary>
+ public float ScaleZ
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.SCALE_Z).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets the world scale of View.
+ /// </summary>
+ public Vector3 WorldScale
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.WORLD_SCALE).Get(temp);
+ return temp;
+ }
+ }
+
+ /// <summary>
+ /// Retrieves the visibility flag of an view.
+ /// </summary>
+ /// <remarks>
+ /// If an view is not visible, then the view and its children will not be rendered.
+ /// This is regardless of the individual visibility values of the children i.e.an view will only be rendered if all of its parents have visibility set to true.
+ /// </remarks>
+ public bool Visible
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.VISIBLE).Get(ref temp);
+ return temp;
+ }/* only get is required : removed
+ set
+ {
+ SetProperty(View.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
+ }*/
+ }
+
+ /// <summary>
+ /// Gets/Sets the view's mix color red.
+ /// </summary>
+ public float ColorRed
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_RED).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_RED, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the view's mix color green.
+ /// </summary>
+ public float ColorGreen
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_GREEN).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_GREEN, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the view's mix color blue
+ /// </summary>
+ public float ColorBlue
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_BLUE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_BLUE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the view's mix color alpha.
+ /// </summary>
+ public float ColorAlpha
+ {
+ get
+ {
+ float temp = 0.0f;
+ GetProperty(View.Property.COLOR_ALPHA).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets the view's world color.
+ /// </summary>
+ public Vector4 WorldColor
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.WORLD_COLOR).Get(temp);
+ return temp;
+ }
+ }
+
+ internal Matrix WorldMatrix
+ {
+ get
+ {
+ Matrix temp = new Matrix();
+ GetProperty(View.Property.WORLD_MATRIX).Get(temp);
+ return temp;
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the View's name.
+ /// </summary>
+ public string Name
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.NAME).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.NAME, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of whether an view should emit touch or hover signals.
+ /// </summary>
+ public bool Sensitive
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.SENSITIVE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of whether the view should receive a notification when touch or hover motion events leave the boundary of the view.
+ /// </summary>
+ public bool LeaveRequired
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.LEAVE_REQUIRED).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of whether a child view inherits it's parent's orientation.
+ /// </summary>
+ public bool InheritOrientation
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.INHERIT_ORIENTATION).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of whether a child view inherits it's parent's scale.
+ /// </summary>
+ public bool InheritScale
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.INHERIT_SCALE).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the view's color mode.<br>
+ /// This specifies whether the View uses its own color, or inherits its parent color.<br>
+ /// The default is UseOwnMultiplyParentAlpha.<br>
+ /// </summary>
+ public ColorMode ColorMode
+ {
+ get
+ {
+ string temp;
+ if (GetProperty(View.Property.COLOR_MODE).Get(out temp) == false)
+ {
+#if DEBUG_ON
+ Tizen.Log.Error("NUI", "ColorMode get error!");
+#endif
+ }
+ switch (temp)
+ {
+ case "USE_OWN_COLOR":
+ return ColorMode.UseOwnColor;
+ case "USE_PARENT_COLOR":
+ return ColorMode.UseParentColor;
+ case "USE_OWN_MULTIPLY_PARENT_COLOR":
+ return ColorMode.UseOwnMultiplyParentColor;
+ case "USE_OWN_MULTIPLY_PARENT_ALPHA":
+ return ColorMode.UseOwnMultiplyParentAlpha;
+ default:
+ return ColorMode.UseOwnMultiplyParentAlpha;
+ }
+ }
+ set
+ {
+ SetProperty(View.Property.COLOR_MODE, new Tizen.NUI.PropertyValue((int)value));
+ }
+ }
+
+ public string PositionInheritance
+ {
+ get
+ {
+ string temp;
+ GetProperty(View.Property.POSITION_INHERITANCE).Get(out temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.POSITION_INHERITANCE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of how the view and its children should be drawn.<br>
+ /// Not all views are renderable, but DrawMode can be inherited from any view.<br>
+ /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.<br>
+ /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br>
+ /// Overlay views are drawn in a separate pass, after all non-overlay views within the Layer.<br>
+ /// For overlay views, the drawing order is with respect to tree levels of Views, and depth-testing will not be used.<br>
+ /// </summary>
+ public DrawModeType DrawMode
+ {
+ get
+ {
+ string temp;
+ if (GetProperty(View.Property.DRAW_MODE).Get(out temp) == false)
+ {
+#if DEBUG_ON
+ Tizen.Log.Error("NUI", "DrawMode get error!");
+#endif
+ }
+ switch (temp)
+ {
+ case "NORMAL":
+ return DrawModeType.Normal;
+ case "OVERLAY_2D":
+ return DrawModeType.Overlay2D;
+ case "STENCIL":
+ return DrawModeType.Stencil;
+ default:
+ return DrawModeType.Normal;
+ }
+ }
+ set
+ {
+ SetProperty(View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the relative to parent size factor of the view.<br>
+ /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br>
+ /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br>
+ /// </summary>
+ public Vector3 SizeModeFactor
+ {
+ get
+ {
+ Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the width resize policy to be used.
+ /// </summary>
+ public ResizePolicyType WidthResizePolicy
+ {
+ get
+ {
+ string temp;
+ if (GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
+ {
+#if DEBUG_ON
+ Tizen.Log.Error("NUI", "WidthResizePolicy get error!");
+#endif
+ }
+ switch (temp)
+ {
+ case "FIXED":
+ return ResizePolicyType.Fixed;
+ case "USE_NATURAL_SIZE":
+ return ResizePolicyType.UseNaturalSize;
+ case "FILL_TO_PARENT":
+ return ResizePolicyType.FillToParent;
+ case "SIZE_RELATIVE_TO_PARENT":
+ return ResizePolicyType.SizeRelativeToParent;
+ case "SIZE_FIXED_OFFSET_FROM_PARENT":
+ return ResizePolicyType.SizeFixedOffsetFromParent;
+ case "FIT_TO_CHILDREN":
+ return ResizePolicyType.FitToChildren;
+ case "DIMENSION_DEPENDENCY":
+ return ResizePolicyType.DimensionDependency;
+ case "USE_ASSIGNED_SIZE":
+ return ResizePolicyType.UseAssignedSize;
+ default:
+ return ResizePolicyType.Fixed;
+ }
+ }
+ set
+ {
+ SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the height resize policy to be used.
+ /// </summary>
+ public ResizePolicyType HeightResizePolicy
+ {
+ get
+ {
+ string temp;
+ if (GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
+ {
+#if DEBUG_ON
+ Tizen.Log.Error("NUI", "HeightResizePolicy get error!");
+#endif
+ }
+ switch (temp)
+ {
+ case "FIXED":
+ return ResizePolicyType.Fixed;
+ case "USE_NATURAL_SIZE":
+ return ResizePolicyType.UseNaturalSize;
+ case "FILL_TO_PARENT":
+ return ResizePolicyType.FillToParent;
+ case "SIZE_RELATIVE_TO_PARENT":
+ return ResizePolicyType.SizeRelativeToParent;
+ case "SIZE_FIXED_OFFSET_FROM_PARENT":
+ return ResizePolicyType.SizeFixedOffsetFromParent;
+ case "FIT_TO_CHILDREN":
+ return ResizePolicyType.FitToChildren;
+ case "DIMENSION_DEPENDENCY":
+ return ResizePolicyType.DimensionDependency;
+ case "USE_ASSIGNED_SIZE":
+ return ResizePolicyType.UseAssignedSize;
+ default:
+ return ResizePolicyType.Fixed;
+ }
+ }
+ set
+ {
+ SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the policy to use when setting size with size negotiation.<br>
+ /// Defaults to SizeScalePolicyType.UseSizeSet.<br>
+ /// </summary>
+ public SizeScalePolicyType SizeScalePolicy
+ {
+ get
+ {
+ string temp;
+ if (GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
+ {
+#if DEBUG_ON
+ Tizen.Log.Error("NUI", "SizeScalePolicy get error!");
+#endif
+ }
+ switch (temp)
+ {
+ case "USE_SIZE_SET":
+ return SizeScalePolicyType.UseSizeSet;
+ case "FIT_WITH_ASPECT_RATIO":
+ return SizeScalePolicyType.FitWithAspectRatio;
+ case "FILL_WITH_ASPECT_RATIO":
+ return SizeScalePolicyType.FillWithAspectRatio;
+ default:
+ return SizeScalePolicyType.UseSizeSet;
+ }
+ }
+ set
+ {
+ string valueToString = "";
+ switch (value)
+ {
+ case SizeScalePolicyType.UseSizeSet:
+ {
+ valueToString = "USE_SIZE_SET";
+ break;
+ }
+ case SizeScalePolicyType.FitWithAspectRatio:
+ {
+ valueToString = "FIT_WITH_ASPECT_RATIO";
+ break;
+ }
+ case SizeScalePolicyType.FillWithAspectRatio:
+ {
+ valueToString = "FILL_WITH_ASPECT_RATIO";
+ break;
+ }
+ default:
+ {
+ valueToString = "USE_SIZE_SET";
+ break;
+ }
+ }
+ SetProperty(View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of whether the width size is dependent on height size.
+ /// </summary>
+ public bool WidthForHeight
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the status of whether the height size is dependent on width size.
+ /// </summary>
+ public bool HeightForWidth
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the padding for use in layout.
+ /// </summary>
+ public Vector4 Padding
+ {
+ get
+ {
+ Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
+ GetProperty(View.Property.PADDING).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the minimum size an view can be assigned in size negotiation.
+ /// </summary>
+ public Size2D MinimumSize
+ {
+ get
+ {
+ Size2D temp = new Size2D(0, 0);
+ GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets the maximum size an view can be assigned in size negotiation.
+ /// </summary>
+ public Size2D MaximumSize
+ {
+ get
+ {
+ Size2D temp = new Size2D(0, 0);
+ GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets whether a child view inherits it's parent's position.<br>
+ /// Default is to inherit.<br>
+ /// Switching this off means that using Position sets the view's world position, i.e. translates from the world origin(0,0,0) to the anchor point of the view.<br>
+ /// </summary>
+ public bool InheritPosition
+ {
+ get
+ {
+ bool temp = false;
+ GetProperty(View.Property.INHERIT_POSITION).Get(ref temp);
+ return temp;
+ }
+ set
+ {
+ SetProperty(View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets clipping behavior(mode) of it's children.
+ /// </summary>
+ public ClippingModeType ClippingMode
+ {
+ get
+ {
+ string temp;
+ if (GetProperty(View.Property.CLIPPING_MODE).Get(out temp) == false)
+ {
+#if DEBUG_ON
+ Tizen.Log.Error("NUI", "ClippingMode get error!");
+#endif
+ }
+ switch (temp)
+ {
+ case "DISABLED":
+ return ClippingModeType.Disabled;
+ case "CLIP_CHILDREN":
+ return ClippingModeType.ClipChildren;
+ default:
+ return ClippingModeType.Disabled;
+ }
+ }
+ set
+ {
+ SetProperty(View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
+ }
+ }
}
}
+++ /dev/null
-// Copyright (c) 2017 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.
-//
-//
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-// Some have been manually changed
-
-namespace Tizen.NUI
-{
-
- /// <summary>
- /// This class will be deprecated.<br>
- /// CameraActor controls a camera.<br>
- /// Allows the developer to use actor semantics to control a camera.<br>
- /// NUI has a concept of a camera to display its virtual 3D world to a 2D screen.<br>
- /// There are 2 ways of using the camera in NUI:<br>
- /// - For 2D applications, you do not need to care about the camera at all. The default camera is already best suited for 2D applications
- /// (configured to have the origin of the coordinate system at the top-left corner of the screen, and unit 1 as 1 pixel of the screen). This is a typical way.<br>
- /// - For 3D applications, you can change the view by manipulating the camera.You can translate or rotate the camera in this case.<br>
- /// Note that the top-left corner of the screen and unit 1 no longer are (0,0,0) and 1 pixel after manipulating the camera.<br>
- /// There are two types of camera actor, FreeLook and LookAtTarget. By default, the camera actor will be FreeLook.<br>
- /// - A FreeLook camera uses actor's orientation to control where the camera is looking.<br>
- /// If no additional rotations are specified, the camera looks in the negative Z direction.<br>
- /// - For LookAtTarget, the actor's orientation is ignored, instead the camera looks at TargetPosition in world coordinates.<br>
- /// /// </summary>
- public class CameraActor : Actor
- {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal CameraActor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.CameraActor_SWIGUpcast(cPtr), cMemoryOwn)
- {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(CameraActor obj)
- {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- /// <summary>
- /// To make CameraActor instance be disposed.
- /// </summary>
- public override void Dispose()
- {
- if (!Stage.IsInstalled())
- {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock (this)
- {
- if (swigCPtr.Handle != global::System.IntPtr.Zero)
- {
- if (swigCMemOwn)
- {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_CameraActor(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
-
-
- internal class Property : global::System.IDisposable
- {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
- protected bool swigCMemOwn;
-
- internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
- {
- swigCMemOwn = cMemoryOwn;
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
- {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- ~Property()
- {
- Dispose();
- }
-
- public virtual void Dispose()
- {
- lock (this)
- {
- if (swigCPtr.Handle != global::System.IntPtr.Zero)
- {
- if (swigCMemOwn)
- {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_CameraActor_Property(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- }
- }
-
- internal Property() : this(NDalicPINVOKE.new_CameraActor_Property(), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal static readonly int TYPE = NDalicPINVOKE.CameraActor_Property_TYPE_get();
- internal static readonly int PROJECTION_MODE = NDalicPINVOKE.CameraActor_Property_PROJECTION_MODE_get();
- internal static readonly int FIELD_OF_VIEW = NDalicPINVOKE.CameraActor_Property_FIELD_OF_VIEW_get();
- internal static readonly int ASPECT_RATIO = NDalicPINVOKE.CameraActor_Property_ASPECT_RATIO_get();
- internal static readonly int NEAR_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_NEAR_PLANE_DISTANCE_get();
- internal static readonly int FAR_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_FAR_PLANE_DISTANCE_get();
- internal static readonly int LEFT_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_LEFT_PLANE_DISTANCE_get();
- internal static readonly int RIGHT_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_RIGHT_PLANE_DISTANCE_get();
- internal static readonly int TOP_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_TOP_PLANE_DISTANCE_get();
- internal static readonly int BOTTOM_PLANE_DISTANCE = NDalicPINVOKE.CameraActor_Property_BOTTOM_PLANE_DISTANCE_get();
- internal static readonly int TARGET_POSITION = NDalicPINVOKE.CameraActor_Property_TARGET_POSITION_get();
- internal static readonly int PROJECTION_MATRIX = NDalicPINVOKE.CameraActor_Property_PROJECTION_MATRIX_get();
- internal static readonly int VIEW_MATRIX = NDalicPINVOKE.CameraActor_Property_VIEW_MATRIX_get();
- internal static readonly int INVERT_Y_AXIS = NDalicPINVOKE.CameraActor_Property_INVERT_Y_AXIS_get();
-
- }
-
- /// <summary>
- /// Creates an initialized CameraActor handle.
- /// </summary>
- public CameraActor() : this(NDalicPINVOKE.CameraActor_New__SWIG_0(), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
-
- /// <summary>
- /// Creates a CameraActor object.<br>
- /// Sets the default camera perspective projection for the given canvas size.<br>
- /// </summary>
- /// <param name="size">The canvas size</param>
- public CameraActor(Size2D size) : this(NDalicPINVOKE.CameraActor_New__SWIG_1(Size2D.getCPtr(size)), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- }
-
- /// <summary>
- /// Downcasts a handle to CameraActor handle.<br>
- /// If handle points to a CameraActor, the downcast produces valid handle.<br>
- /// If not, the returned handle is left uninitialized.<br>
- /// </summary>
- /// <param name="handle">to An object</param>
- /// <returns>Handle to a CameraActor or an uninitialized handle</returns>
- public new static CameraActor DownCast(BaseHandle handle)
- {
- CameraActor ret = new CameraActor(NDalicPINVOKE.CameraActor_DownCast(BaseHandle.getCPtr(handle)), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal CameraActor(CameraActor copy) : this(NDalicPINVOKE.new_CameraActor__SWIG_1(CameraActor.getCPtr(copy)), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal CameraActor Assign(CameraActor rhs)
- {
- CameraActor ret = new CameraActor(NDalicPINVOKE.CameraActor_Assign(swigCPtr, CameraActor.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetType(CameraType type)
- {
- NDalicPINVOKE.CameraActor_SetType(swigCPtr, (int)type);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal CameraType GetType()
- {
- CameraType ret = (CameraType)NDalicPINVOKE.CameraActor_GetType(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetProjectionMode(ProjectionMode mode)
- {
- NDalicPINVOKE.CameraActor_SetProjectionMode(swigCPtr, (int)mode);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal ProjectionMode GetProjectionMode()
- {
- ProjectionMode ret = (ProjectionMode)NDalicPINVOKE.CameraActor_GetProjectionMode(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetFieldOfView(float fieldOfView)
- {
- NDalicPINVOKE.CameraActor_SetFieldOfView(swigCPtr, fieldOfView);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal float GetFieldOfView()
- {
- float ret = NDalicPINVOKE.CameraActor_GetFieldOfView(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetAspectRatio(float aspectRatio)
- {
- NDalicPINVOKE.CameraActor_SetAspectRatio(swigCPtr, aspectRatio);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal float GetAspectRatio()
- {
- float ret = NDalicPINVOKE.CameraActor_GetAspectRatio(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetNearClippingPlane(float nearClippingPlane)
- {
- NDalicPINVOKE.CameraActor_SetNearClippingPlane(swigCPtr, nearClippingPlane);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal float GetNearClippingPlane()
- {
- float ret = NDalicPINVOKE.CameraActor_GetNearClippingPlane(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetFarClippingPlane(float farClippingPlane)
- {
- NDalicPINVOKE.CameraActor_SetFarClippingPlane(swigCPtr, farClippingPlane);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal float GetFarClippingPlane()
- {
- float ret = NDalicPINVOKE.CameraActor_GetFarClippingPlane(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetTargetPosition(Vector3 targetPosition)
- {
- NDalicPINVOKE.CameraActor_SetTargetPosition(swigCPtr, Vector3.getCPtr(targetPosition));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Vector3 GetTargetPosition()
- {
- Vector3 ret = new Vector3(NDalicPINVOKE.CameraActor_GetTargetPosition(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetInvertYAxis(bool invertYAxis)
- {
- NDalicPINVOKE.CameraActor_SetInvertYAxis(swigCPtr, invertYAxis);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal bool GetInvertYAxis()
- {
- bool ret = NDalicPINVOKE.CameraActor_GetInvertYAxis(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetPerspectiveProjection(Vector2 size)
- {
- NDalicPINVOKE.CameraActor_SetPerspectiveProjection(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetOrthographicProjection(Vector2 size)
- {
- NDalicPINVOKE.CameraActor_SetOrthographicProjection__SWIG_0(swigCPtr, Vector2.getCPtr(size));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void SetOrthographicProjection(float left, float right, float top, float bottom, float near, float far)
- {
- NDalicPINVOKE.CameraActor_SetOrthographicProjection__SWIG_1(swigCPtr, left, right, top, bottom, near, far);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- /// <summary>
- /// Gets/Sets the camera type. The default type is FreeLook
- /// </summary>
- public CameraType Type
- {
- get
- {
- string temp;
- if (GetProperty(CameraActor.Property.TYPE).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "CameraType get error!");
-#endif
- }
- switch (temp)
- {
- case "LOOK_AT_TARGET":
- return CameraType.LookAtTarget;
- case "FREE_LOOK":
- return CameraType.FreeLook;
- default:
- return CameraType.FreeLook;
- }
- }
- set
- {
- string valueToString = "";
- switch (value)
- {
- case CameraType.LookAtTarget:
- {
- valueToString = "LOOK_AT_TARGET";
- break;
- }
- case CameraType.FreeLook:
- {
- valueToString = "FREE_LOOK";
- break;
- }
- default:
- {
- valueToString = "FREE_LOOK";
- break;
- }
- }
- SetProperty(CameraActor.Property.TYPE, new Tizen.NUI.PropertyValue(valueToString));
- }
- }
-
- /// <summary>
- /// Gets/Sets the projection mode.
- /// </summary>
- public ProjectionMode ProjectionMode
- {
- get
- {
- string temp;
- if (GetProperty(CameraActor.Property.PROJECTION_MODE).Get(out temp) == false)
- {
-#if DEBUG_ON
- Tizen.Log.Error("NUI", "ProjectionMode get error!");
-#endif
- }
- switch(temp)
- {
- case "PERSPECTIVE_PROJECTION":
- return ProjectionMode.PerspectiveProjection;
- case "ORTHOGRAPHIC_PROJECTION":
- return ProjectionMode.OrthographicProjection;
- default:
- return ProjectionMode.PerspectiveProjection;
- }
- }
- set
- {
- string valueToString = "";
- switch (value)
- {
- case ProjectionMode.PerspectiveProjection:
- {
- valueToString = "PERSPECTIVE_PROJECTION";
- break;
- }
- case ProjectionMode.OrthographicProjection:
- {
- valueToString = "ORTHOGRAPHIC_PROJECTION";
- break;
- }
- default:
- {
- valueToString = "PERSPECTIVE_PROJECTION";
- break;
- }
- }
- SetProperty(CameraActor.Property.PROJECTION_MODE, new Tizen.NUI.PropertyValue(valueToString));
- }
- }
-
- /// <summary>
- /// Gets/Sets the field of view.
- /// </summary>
- public float FieldOfView
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.FIELD_OF_VIEW).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.FIELD_OF_VIEW, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the aspect ratio of the camera.
- /// </summary>
- public float AspectRatio
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.ASPECT_RATIO).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.ASPECT_RATIO, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets near plane distance.
- /// </summary>
- public float NearPlaneDistance
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.NEAR_PLANE_DISTANCE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.NEAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets far plane distance.
- /// </summary>
- public float FarPlaneDistance
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.FAR_PLANE_DISTANCE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.FAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets left plane distance.
- /// </summary>
- public float LeftPlaneDistance
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.LEFT_PLANE_DISTANCE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.LEFT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets right plane distance.
- /// </summary>
- public float RightPlaneDistance
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.RIGHT_PLANE_DISTANCE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.RIGHT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets top plane distance.
- /// </summary>
- public float TopPlaneDistance
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.TOP_PLANE_DISTANCE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.TOP_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets bottom plane distance.
- /// </summary>
- public float BottomPlaneDistance
- {
- get
- {
- float temp = 0.0f;
- GetProperty(CameraActor.Property.BOTTOM_PLANE_DISTANCE).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.BOTTOM_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- /// <summary>
- /// Gets/Sets the target position of the camera.
- /// </summary>
- public Position TargetPosition
- {
- get
- {
- Position temp = new Position(0.0f, 0.0f, 0.0f);
- GetProperty(CameraActor.Property.TARGET_POSITION).Get(temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.TARGET_POSITION, new Tizen.NUI.PropertyValue(value));
- }
- }
- internal Matrix ProjectionMatrix
- {
- get
- {
- Matrix temp = new Matrix();
- GetProperty(CameraActor.Property.PROJECTION_MATRIX).Get(temp);
- return temp;
- }
- }
-
- internal Matrix ViewMatrix
- {
- get
- {
- Matrix temp = new Matrix();
- GetProperty(CameraActor.Property.VIEW_MATRIX).Get(temp);
- return temp;
- }
- }
-
- /// <summary>
- /// Requests for an inversion on the Y axis on the projection calculation.
- /// </summary>
- public bool InvertYAxis
- {
- get
- {
- bool temp = false;
- GetProperty(CameraActor.Property.INVERT_Y_AXIS).Get(ref temp);
- return temp;
- }
- set
- {
- SetProperty(CameraActor.Property.INVERT_Y_AXIS, new Tizen.NUI.PropertyValue(value));
- }
- }
-
- }
-}
/// </summary>
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~ChildProperty()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// <summary>
/// Enumeration for the primary direction in which content is ordered in the flex container
- /// and on which sides the ?\9cstart??and ?\9cend??are.
+ /// and on which sides the ?�start??and ?�end??are.
/// </summary>
public enum ContentDirectionType
{
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// <summary>
/// PreFocusChange will be triggered before the focus is going to be changed.<br>
- /// FocusManager makes the best guess for which actor to focus towards the given direction, but applications might want to change that.<br>
- /// By connecting with this event, they can check the proposed actor to focus and return a different actor if they wish.<br>
+ /// FocusManager makes the best guess for which view to focus towards the given direction, but applications might want to change that.<br>
+ /// By connecting with this event, they can check the proposed view to focus and return a different view if they wish.<br>
/// This event is only triggered when the navigation key is pressed and KeyboardFocusManager tries to move the focus automatically.<br>
/// It won't be emitted for focus movement by calling SetCurrentFocusView directly.<br>
/// </summary>
View view = null;
PreFocusChangeEventArgs e = new PreFocusChangeEventArgs();
- e.CurrentView = View.GetViewFromPtr(current);
- e.ProposedView = View.GetViewFromPtr(proposed);
+ if (current != global::System.IntPtr.Zero)
+ {
+ e.CurrentView = View.GetViewFromPtr(current);
+ }
+ if (proposed != global::System.IntPtr.Zero)
+ {
+ e.ProposedView = View.GetViewFromPtr(proposed);
+ }
e.Direction = direction;
if (_preFocusChangeEventHandler != null)
if (view)
{
- return view.GetPtrfromActor();
+ return view.GetPtrfromView();
}
else
{
- if (e.ProposedView) return proposed;
- else return current;
+ //if (e.ProposedView) return proposed;
+ //else return current;
+ return current; //xb.teng
}
}
private FocusChangedEventCallback _focusChangedEventCallback;
/// <summary>
- /// FocusGroupChanged will be triggered after the current focused actor has been changed.
+ /// FocusGroupChanged will be triggered after the current focused view has been changed.
/// </summary>
public event EventHandler<FocusChangedEventArgs> FocusChanged
{
private FocusedViewEnterKeyEventCallback _focusedViewEnterKeyEventCallback;
/// <summary>
- /// FocusedViewEnterKeyPressed will be triggered when the current focused actor has the enter key pressed on it.
+ /// FocusedViewEnterKeyPressed will be triggered when the current focused view has the enter key pressed on it.
/// </summary>
public event EventHandler<FocusedViewEnterKeyEventArgs> FocusedViewEnterKeyPressed
{
if (_focusedViewEnterKeyEventCallback == null)
{
_focusedViewEnterKeyEventCallback = OnFocusedViewEnterKey;
- FocusedActorEnterKeySignal().Connect(_focusedViewEnterKeyEventCallback);
+ FocusedViewEnterKeySignal().Connect(_focusedViewEnterKeyEventCallback);
}
_focusedViewEnterKeyEventHandler += value;
}
{
_focusedViewEnterKeyEventHandler -= value;
- if (_focusedViewEnterKeyEventCallback == null && FocusedActorEnterKeySignal().Empty() == false)
+ if (_focusedViewEnterKeyEventCallback == null && FocusedViewEnterKeySignal().Empty() == false)
{
- FocusedActorEnterKeySignal().Disconnect(_focusedViewEnterKeyEventCallback);
+ FocusedViewEnterKeySignal().Disconnect(_focusedViewEnterKeyEventCallback);
}
}
}
/// <returns>Whether the focus is successful or not</returns>
public bool SetCurrentFocusView(View view)
{
- bool ret = NDalicManualPINVOKE.FocusManager_SetCurrentFocusActor(swigCPtr, Actor.getCPtr(view));
+ bool ret = NDalicManualPINVOKE.FocusManager_SetCurrentFocusActor(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <summary>
- /// Gets the current focused actor.
+ /// Gets the current focused view.
/// </summary>
/// <returns>A handle to the current focused View or an empty handle if no View is focused</returns>
public View GetCurrentFocusView()
{
- View ret = View.DownCast(new Actor(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true));
+ View ret = new View(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (ret.HasBody() == false)
{
}
/// <summary>
- /// Clears the focus from the current focused actor if any, so that no actor is focused in the focus chain.<br>
+ /// Clears the focus from the current focused view if any, so that no view is focused in the focus chain.<br>
/// It will emit FocusChanged event without current focused View.<br>
/// </summary>
public void ClearFocus()
}
/// <summary>
- /// Sets whether an View is a focus group that can limit the scope of focus movement to its child actors in the focus chain.<br>
+ /// Sets whether an View is a focus group that can limit the scope of focus movement to its child views in the focus chain.<br>
/// Layout controls set themselves as focus groups by default.<br>
/// </summary>
/// <param name="view">The View to be set as a focus group</param>
/// <param name="isFocusGroup">Whether to set the View as a focus group or not</param>
public void SetAsFocusGroup(View view, bool isFocusGroup)
{
- NDalicManualPINVOKE.FocusManager_SetAsFocusGroup(swigCPtr, Actor.getCPtr(view), isFocusGroup);
+ NDalicManualPINVOKE.FocusManager_SetAsFocusGroup(swigCPtr, View.getCPtr(view), isFocusGroup);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Checks whether the actor is set as a focus group or not.
+ /// Checks whether the view is set as a focus group or not.
/// </summary>
/// <param name="view">The View to be checked</param>
/// <returns>Whether the View is set as a focus group</returns>
public bool IsFocusGroup(View view)
{
- bool ret = NDalicManualPINVOKE.FocusManager_IsFocusGroup(swigCPtr, Actor.getCPtr(view));
+ bool ret = NDalicManualPINVOKE.FocusManager_IsFocusGroup(swigCPtr, View.getCPtr(view));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <summary>
- /// Returns the closest ancestor of the given actor that is a focus group.
+ /// Returns the closest ancestor of the given view that is a focus group.
/// </summary>
/// <param name="view">The View to be checked for its focus group</param>
/// <returns>The focus group the given view belongs to or an empty handle if the given view</returns>
public View GetFocusGroup(View view)
{
- View ret = View.DownCast(new Actor(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(view)), true));
+ View ret = new View(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, View.getCPtr(view)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (ret.HasBody() == false)
{
internal void SetFocusIndicatorView(View indicator)
{
- NDalicManualPINVOKE.FocusManager_SetFocusIndicatorActor(swigCPtr, Actor.getCPtr(indicator));
+ NDalicManualPINVOKE.FocusManager_SetFocusIndicatorActor(swigCPtr, View.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
internal View GetFocusIndicatorView()
{
- View ret = View.DownCast(new Actor(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true));
+ View ret = new View(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (ret.HasBody() == false)
{
return ret;
}
- internal ActorSignal FocusedActorEnterKeySignal()
+ internal ViewSignal FocusedViewEnterKeySignal()
{
- ActorSignal ret = new ActorSignal(NDalicManualPINVOKE.FocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
+ ViewSignal ret = new ViewSignal(NDalicManualPINVOKE.FocusManager_FocusedActorEnterKeySignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
}
/// <summary>
- /// ICustomFocusAlgorithm is used to provide custom keyboard focus algorithm for retrieving the next focusable actor.<br>
+ /// ICustomFocusAlgorithm is used to provide custom keyboard focus algorithm for retrieving the next focusable view.<br>
/// The application can implement the interface and override the keyboard focus behaviour.<br>
- /// If focus is changing within a layout container, then the layout container is queried first to provide the next focusable actor.<br>
- /// If this does not provide a valid actor, then the Keyboard FocusManager will check focusable properties to determine next focusable actor.<br>
- /// If focusable properties are not set, then the Keyboard FocusManager calls the GetNextFocusableActor() method of this interface.<br>
+ /// If focus is changing within a layout container, then the layout container is queried first to provide the next focusable view.<br>
+ /// If this does not provide a valid view, then the Keyboard FocusManager will check focusable properties to determine next focusable actor.<br>
+ /// If focusable properties are not set, then the Keyboard FocusManager calls the GetNextFocusableView() method of this interface.<br>
/// </summary>
public interface ICustomFocusAlgorithm
{
- View GetNextFocusableActor(View current, View proposed, View.FocusDirection direction);
+ View GetNextFocusableView(View current, View proposed, View.FocusDirection direction);
}
private class CustomAlgorithmInterfaceWrapper : CustomAlgorithmInterface
_customFocusAlgorithm = customFocusAlgorithm;
}
- public override Actor GetNextFocusableActor(Actor current, Actor proposed, View.FocusDirection direction)
+ public override View GetNextFocusableView(View current, View proposed, View.FocusDirection direction)
{
View currentView = View.DownCast<View>(current);
View proposedView = View.DownCast<View>(proposed);
- return _customFocusAlgorithm.GetNextFocusableActor(currentView, proposedView, direction);
+ return _customFocusAlgorithm.GetNextFocusableView(currentView, proposedView, direction);
}
}
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
namespace Tizen.NUI
{
-
+ using Tizen.NUI.BaseComponents;
/// <summary>
/// Hover events are a collection of points at a specific moment in time.<br>
/// When a multi event occurs, each point represents the points that are currently being
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
}
/// <summary>
- /// Retrieves the actor that was underneath the point specified.
+ /// Retrieves the view that was underneath the point specified.
/// </summary>
/// <param name="point">The point required</param>
- /// <returns>The actor that was underneath the point specified</returns>
- public Actor GetHitActor(uint point)
+ /// <returns>The view that was underneath the point specified</returns>
+ public View GetHitView(uint point)
{
if (point < points.Count)
{
- return points[(int)point].hitActor;
+ return points[(int)point].hitView;
}
else
{
// Return a native empty handle
- Actor actor = new Actor();
- actor.Reset();
- return actor;
+ View view = new View();
+ view.Reset();
+ return view;
}
}
/// <summary>
- /// Retrieves the co-ordinates relative to the top-left of the hit-actor at the point specified.
+ /// Retrieves the co-ordinates relative to the top-left of the hit-view at the point specified.
/// </summary>
/// <param name="point">The point required</param>
- /// <returns>The co-ordinates relative to the top-left of the hit-actor of the point specified</returns>
+ /// <returns>The co-ordinates relative to the top-left of the hit-view of the point specified</returns>
public Vector2 GetLocalPosition(uint point)
{
if (point < points.Count)
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
namespace Tizen.NUI
{
-
+ using Tizen.NUI.BaseComponents;
/// <summary>
/// Layers provide a mechanism for overlaying groups of actors on top of each other.
/// </summary>
- public class Layer : Actor
+ public class Layer : Animatable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- public override void Dispose()
+ public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
global::System.GC.SuppressFinalize(this);
- base.Dispose();
+ //base.Dispose(); //xb.teng
}
}
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
return ret;
}
+ public View FindChildById(uint id)
+ {
+ View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public void Add(View child)
+ {
+ NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public void Remove(View child)
+ {
+ NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
+ if (NDalicPINVOKE.SWIGPendingException.Pending)
+ throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
/// <summary>
/// Queries the depth of the layer.<br>
/// 0 is the bottom most layer, higher number is on top.<br>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// <summary>
/// The instance of the Dali Stage.
/// </summary>
- private Stage _stage;
+ private Window _window;
/// <summary>
/// The default constructor.
#if DEBUG_ON
Tizen.Log.Debug("NUI", "##### 2) DisposeQueue.Instance.Initialize()!");
#endif
- _stage = Stage.Instance;
- _stage.SetBackgroundColor(Color.White);
+ _window = Window.Instance;
+ _window.SetBackgroundColor(Color.White);
LOG("OnPreCreate() is called!");
}
/// <summary>
/// Size is to use the actor's natural size
/// </summary>
- /// <see cref="Actor.GetNaturalSize"/>
+ /// <see cref="View.GetNaturalSize"/>
UseNaturalSize,
/// <summary>
/// Size is to fill up to the actor's parent's bounds. Aspect ratio is not maintained.
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// A 3D parametric curve.<br>
/// Paths can be used to animate position and orientation of actors.<br>
/// </summary>
- public class Path : Handle
+ public class Path : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- GetProperty(Path.Property.POINTS).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, Path.Property.POINTS).Get(temp);
return temp;
}
set
{
- SetProperty(Path.Property.POINTS, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, Path.Property.POINTS, new Tizen.NUI.PropertyValue(value));
}
}
get
{
Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
- GetProperty(Path.Property.CONTROL_POINTS).Get(temp);
+ Tizen.NUI.Object.GetProperty(swigCPtr, Path.Property.CONTROL_POINTS).Get(temp);
return temp;
}
set
{
- SetProperty(Path.Property.CONTROL_POINTS, new Tizen.NUI.PropertyValue(value));
+ Tizen.NUI.Object.SetProperty(swigCPtr, Path.Property.CONTROL_POINTS, new Tizen.NUI.PropertyValue(value));
}
}
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
}
public virtual void Dispose() {
- if (!Stage.IsInstalled()) {
+ if (!Window.IsInstalled()) {
DisposeQueue.Instance.Add(this);
return;
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// </summary>
/// <param name="arg0">A valid handle to the target object</param>
/// <param name="propertyIndex">The index of a property</param>
- public Property(Handle arg0, int propertyIndex) : this(NDalicPINVOKE.new_Property__SWIG_0(Handle.getCPtr(arg0), propertyIndex), true)
+ public Property(Animatable arg0, int propertyIndex) : this(NDalicPINVOKE.new_Property__SWIG_0(Animatable.getCPtr(arg0), propertyIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <param name="arg0">A valid handle to the target object</param>
/// <param name="propertyIndex">The index of a property</param>
/// <param name="componentIndex">Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for main property (default is -1)</param>
- public Property(Handle arg0, int propertyIndex, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_1(Handle.getCPtr(arg0), propertyIndex, componentIndex), true)
+ public Property(Animatable arg0, int propertyIndex, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_1(Animatable.getCPtr(arg0), propertyIndex, componentIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// </summary>
/// <param name="arg0">A valid handle to the target object</param>
/// <param name="propertyName">The property name</param>
- public Property(Handle arg0, string propertyName) : this(NDalicPINVOKE.new_Property__SWIG_2(Handle.getCPtr(arg0), propertyName), true)
+ public Property(Animatable arg0, string propertyName) : this(NDalicPINVOKE.new_Property__SWIG_2(Animatable.getCPtr(arg0), propertyName), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <param name="arg0">A valid handle to the target object</param>
/// <param name="propertyName">The property name</param>
/// <param name="componentIndex">Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for main property (default is -1)</param>
- public Property(Handle arg0, string propertyName, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_3(Handle.getCPtr(arg0), propertyName, componentIndex), true)
+ public Property(Animatable arg0, string propertyName, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_3(Animatable.getCPtr(arg0), propertyName, componentIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Handle _object
+ internal Animatable _object
{
set
{
- NDalicPINVOKE.Property__object_set(swigCPtr, Handle.getCPtr(value));
+ NDalicPINVOKE.Property__object_set(swigCPtr, Animatable.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
get
{
- Handle ret = new Handle(NDalicPINVOKE.Property__object_get(swigCPtr), false);
+ Animatable ret = new Animatable(NDalicPINVOKE.Property__object_get(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
~PropertyArray()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~PropertyKey()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~PropertyMap()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~PropertyValue()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
namespace Tizen.NUI
{
-
+ using Tizen.NUI.BaseComponents;
/// <summary>
/// Interface to encapsulate information required for relayout.
/// </summary>
/// </summary>
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// <summary>
/// Adds relayout information to the container if it doesn't already exist.
/// </summary>
- /// <param name="actor">The actor to relayout</param>
+ /// <param name="view">The view to relayout</param>
/// <param name="size">The size to relayout</param>
- public virtual void Add(Actor actor, Size2D size)
+ public virtual void Add(View view, Size2D size)
{
- NDalicPINVOKE.RelayoutContainer_Add(swigCPtr, Actor.getCPtr(actor), Size2D.getCPtr(size));
+ NDalicPINVOKE.RelayoutContainer_Add(swigCPtr, View.getCPtr(view), Size2D.getCPtr(size));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// </summary>
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// </summary>
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
+++ /dev/null
-//------------------------------------------------------------------------------
-// <auto-generated />
-//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
-//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
-
-namespace Tizen.NUI
-{
-
- using System;
- using System.Runtime.InteropServices;
-
- /// <summary>
- /// The Stage is a top-level object used for displaying a tree of Actors.<br>
- /// Stage is a top-level object that represents the entire screen.<br>
- /// It is used for displaying a hierarchy of actors managed by the scene graph structure,
- /// which means an actor inherits a position relative to its parent,
- /// and can be moved in relation to this point.<br>
- /// The stage instance is a singleton object (the only instance of its class during the
- /// lifetime of the program). You can get it using a static function.<br>
- /// To display the contents of an actor, it must be added to a stage.<br>
- /// </summary>
- public class Stage : BaseHandle
- {
- private global::System.Runtime.InteropServices.HandleRef swigCPtr;
-
- internal Stage(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Stage_SWIGUpcast(cPtr), cMemoryOwn)
- {
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
- }
-
- internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Stage obj)
- {
- return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
- }
-
- /// <summary>
- /// Dispose.
- /// </summary>
- public override void Dispose()
- {
- if (!Stage.IsInstalled())
- {
- DisposeQueue.Instance.Add(this);
- return;
- }
-
- lock (this)
- {
- if (swigCPtr.Handle != global::System.IntPtr.Zero)
- {
- if (swigCMemOwn)
- {
- swigCMemOwn = false;
- NDalicPINVOKE.delete_Stage(swigCPtr);
- }
- swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
- }
- global::System.GC.SuppressFinalize(this);
- base.Dispose();
- }
- }
-
- /// <summary>
- /// Touch event argument.
- /// </summary>
- public class TouchEventArgs : EventArgs
- {
- private Touch _touch;
-
- /// <summary>
- /// Touch.
- /// </summary>
- public Touch Touch
- {
- get
- {
- return _touch;
- }
- set
- {
- _touch = value;
- }
- }
- }
-
- private event EventHandler<TouchEventArgs> _stageTouchHandler;
- private EventCallbackDelegateType1 _stageTouchCallbackDelegate;
-
- /// <summary>
- /// This is emitted when the screen is touched and when the touch ends.<br>
- /// If there are multiple touch points, then this will be emitted when the first touch occurs and
- /// then when the last finger is lifted.<br>
- /// An interrupted event will also be emitted (if it occurs).<br>
- /// </summary>
- public event EventHandler<TouchEventArgs> Touch
- {
- add
- {
- if (_stageTouchHandler == null)
- {
- _stageTouchCallbackDelegate = OnStageTouch;
- TouchSignal().Connect(_stageTouchCallbackDelegate);
- }
- _stageTouchHandler += value;
- }
- remove
- {
- _stageTouchHandler -= value;
- if (_stageTouchHandler == null && TouchSignal().Empty() == false)
- {
- TouchSignal().Disconnect(_stageTouchCallbackDelegate);
- }
- }
- }
-
- private void OnStageTouch(IntPtr data)
- {
- TouchEventArgs e = new TouchEventArgs();
-
- if (data != null)
- {
- e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(data);
- }
-
- if (_stageTouchHandler != null)
- {
- _stageTouchHandler(this, e);
- }
- }
-
- /// <summary>
- /// Wheel event arguments.
- /// </summary>
- public class WheelEventArgs : EventArgs
- {
- private Wheel _wheel;
-
- /// <summary>
- /// Wheel.
- /// </summary>
- public Wheel Wheel
- {
- get
- {
- return _wheel;
- }
- set
- {
- _wheel = value;
- }
- }
- }
-
- private event EventHandler<WheelEventArgs> _stageWheelHandler;
- private EventCallbackDelegateType1 _stageWheelCallbackDelegate;
-
- /// <summary>
- /// Event emitted when wheel event is received.
- /// </summary>
- public event EventHandler<WheelEventArgs> Wheel
- {
- add
- {
- if (_stageWheelHandler == null)
- {
- _stageWheelCallbackDelegate = OnStageWheel;
- WheelEventSignal().Connect(_stageWheelCallbackDelegate);
- }
- _stageWheelHandler += value;
- }
- remove
- {
- _stageWheelHandler -= value;
- if (_stageWheelHandler == null && WheelEventSignal().Empty() == false)
- {
- WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
- }
- }
- }
-
- private void OnStageWheel(IntPtr data)
- {
- WheelEventArgs e = new WheelEventArgs();
-
- if (data != null)
- {
- e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(data);
- }
-
- if (_stageWheelHandler != null)
- {
- _stageWheelHandler(this, e);
- }
- }
-
- /// <summary>
- /// Key event arguments.
- /// </summary>
- public class KeyEventArgs : EventArgs
- {
- private Key _key;
-
- /// <summary>
- /// Key
- /// </summary>
- public Key Key
- {
- get
- {
- return _key;
- }
- set
- {
- _key = value;
- }
- }
- }
-
- private event EventHandler<KeyEventArgs> _stageKeyHandler;
- private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
-
- /// <summary>
- /// Event emitted when key event is received.
- /// </summary>
- public event EventHandler<KeyEventArgs> Key
- {
- add
- {
- if (_stageKeyHandler == null)
- {
- _stageKeyCallbackDelegate = OnStageKey;
- KeyEventSignal().Connect(_stageKeyCallbackDelegate);
- }
- _stageKeyHandler += value;
- }
- remove
- {
- _stageKeyHandler -= value;
- if (_stageKeyHandler == null && KeyEventSignal().Empty() == false)
- {
- KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
- }
- }
- }
-
- // Callback for Stage KeyEventsignal
- private void OnStageKey(IntPtr data)
- {
- KeyEventArgs e = new KeyEventArgs();
-
- if (data != null)
- {
- e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
- }
-
- if (_stageKeyHandler != null)
- {
- //here we send all data to user event handlers
- _stageKeyHandler(this, e);
- }
- }
-
-
- private event EventHandler _stageEventProcessingFinishedEventHandler;
- private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
-
- internal event EventHandler EventProcessingFinished
- {
- add
- {
- if (_stageEventProcessingFinishedEventHandler == null)
- {
- _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
- EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
- }
- _stageEventProcessingFinishedEventHandler += value;
-
- }
- remove
- {
- _stageEventProcessingFinishedEventHandler -= value;
- if (_stageEventProcessingFinishedEventHandler == null && EventProcessingFinishedSignal().Empty() == false)
- {
- EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
- }
- }
- }
-
- // Callback for Stage EventProcessingFinishedSignal
- private void OnEventProcessingFinished()
- {
- if (_stageEventProcessingFinishedEventHandler != null)
- {
- _stageEventProcessingFinishedEventHandler(this, null);
- }
- }
-
-
- private EventHandler _stageContextLostEventHandler;
- private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
-
- internal event EventHandler ContextLost
- {
- add
- {
- if (_stageContextLostEventHandler == null)
- {
- _stageContextLostEventCallbackDelegate = OnContextLost;
- ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
- }
- _stageContextLostEventHandler += value;
- }
- remove
- {
- _stageContextLostEventHandler -= value;
- if (_stageContextLostEventHandler == null && ContextLostSignal().Empty() == false)
- {
- ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
- }
- }
- }
-
- // Callback for Stage ContextLostSignal
- private void OnContextLost()
- {
- if (_stageContextLostEventHandler != null)
- {
- _stageContextLostEventHandler(this, null);
- }
- }
-
-
- private EventHandler _stageContextRegainedEventHandler;
- private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
-
- internal event EventHandler ContextRegained
- {
- add
- {
- if (_stageContextRegainedEventHandler == null)
- {
- _stageContextRegainedEventCallbackDelegate = OnContextRegained;
- ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
- }
- _stageContextRegainedEventHandler += value;
- }
- remove
- {
- _stageContextRegainedEventHandler -= value;
- if (_stageContextRegainedEventHandler == null && ContextRegainedSignal().Empty() == false)
- {
- this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
- }
- }
- }
-
- // Callback for Stage ContextRegainedSignal
- private void OnContextRegained()
- {
- if (_stageContextRegainedEventHandler != null)
- {
- _stageContextRegainedEventHandler(this, null);
- }
- }
-
-
- private EventHandler _stageSceneCreatedEventHandler;
- private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
-
- internal event EventHandler SceneCreated
- {
- add
- {
- if (_stageSceneCreatedEventHandler == null)
- {
- _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
- SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
- }
- _stageSceneCreatedEventHandler += value;
- }
- remove
- {
- _stageSceneCreatedEventHandler -= value;
- if (_stageSceneCreatedEventHandler == null && SceneCreatedSignal().Empty() == false)
- {
- SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
- }
- }
- }
-
- // Callback for Stage SceneCreatedSignal
- private void OnSceneCreated()
- {
- if (_stageSceneCreatedEventHandler != null)
- {
- _stageSceneCreatedEventHandler(this, null);
- }
- }
-
- /// <summary>
- /// Stage size property (read-only).
- /// </summary>
- public Size2D Size
- {
- get
- {
- Size2D ret = GetSize();
- return ret;
- }
- }
-
- /// <summary>
- /// Background color property.
- /// </summary>
- public Color BackgroundColor
- {
- set
- {
- SetBackgroundColor(value);
- }
- get
- {
- Color ret = GetBackgroundColor();
- return ret;
- }
- }
-
- /// <summary>
- /// Dpi property (read-only).<br>
- /// Retrieves the DPI of the display device to which the stage is connected.<br>
- /// </summary>
- public Vector2 Dpi
- {
- get
- {
- return GetDpi();
- }
- }
-
- /// <summary>
- /// Layer count property (read-only).<br>
- /// Queries the number of on-stage layers.<br>
- /// </summary>
- public uint LayerCount
- {
- get
- {
- return GetLayerCount();
- }
- }
-
- private static readonly Stage instance = Stage.GetCurrent();
-
- /// <summary>
- /// Stage instance property (read-only).<br>
- /// Gets the current Stage.<br>
- /// </summary>
- public static Stage Instance
- {
- get
- {
- return instance;
- }
- }
-
- /// <summary>
- /// Get default ( root ) layer.
- /// </summary>
- /// <returns>The root layer</returns>
- public Layer GetDefaultLayer()
- {
- return this.GetRootLayer();
- }
-
- /// <summary>
- /// Add layer to the Stage.
- /// </summary>
- /// <param name="layer">Layer to add</param>
- public void AddLayer(Layer layer)
- {
- this.Add((Actor)layer);
- }
-
- /// <summary>
- /// Remove layer from the Stage.
- /// </summary>
- /// <param name="layer">Layer to remove</param>
- public void RemoveLayer(Layer layer)
- {
- this.Remove((Actor)layer);
- }
-
- internal static Vector4 DEFAULT_BACKGROUND_COLOR
- {
- get
- {
- global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
- Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- internal static Vector4 DEBUG_BACKGROUND_COLOR
- {
- get
- {
- global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
- Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
-
- internal Stage() : this(NDalicPINVOKE.new_Stage__SWIG_0(), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal static Stage GetCurrent()
- {
- Stage ret = new Stage(NDalicPINVOKE.Stage_GetCurrent(), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal static bool IsInstalled()
- {
- bool ret = NDalicPINVOKE.Stage_IsInstalled();
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Stage(Stage handle) : this(NDalicPINVOKE.new_Stage__SWIG_1(Stage.getCPtr(handle)), true)
- {
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Stage Assign(Stage rhs)
- {
- Stage ret = new Stage(NDalicPINVOKE.Stage_Assign(swigCPtr, Stage.getCPtr(rhs)), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void Add(Actor actor)
- {
- NDalicPINVOKE.Stage_Add(swigCPtr, Actor.getCPtr(actor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal void Remove(Actor actor)
- {
- NDalicPINVOKE.Stage_Remove(swigCPtr, Actor.getCPtr(actor));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Size2D GetSize()
- {
- Size2D ret = new Size2D(NDalicPINVOKE.Stage_GetSize(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal RenderTaskList GetRenderTaskList()
- {
- RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal uint GetLayerCount()
- {
- uint ret = NDalicPINVOKE.Stage_GetLayerCount(swigCPtr);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Retrieves the layer at a specified depth.
- /// </summary>
- /// <param name="depth">The depth</param>
- /// <returns>The layer found at the given depth</returns>
- public Layer GetLayer(uint depth)
- {
- Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(swigCPtr, depth), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Layer GetRootLayer()
- {
- Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal void SetBackgroundColor(Color color)
- {
- NDalicPINVOKE.Stage_SetBackgroundColor(swigCPtr, Color.getCPtr(color));
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal Color GetBackgroundColor()
- {
- Color ret = new Color(NDalicPINVOKE.Stage_GetBackgroundColor(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal Vector2 GetDpi()
- {
- Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal ObjectRegistry GetObjectRegistry()
- {
- ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(swigCPtr), true);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- /// <summary>
- /// Keep rendering for at least the given amount of time.
- /// </summary>
- /// <param name="durationSeconds">Time to keep rendering, 0 means render at least one more frame</param>
- public void KeepRendering(float durationSeconds)
- {
- NDalicPINVOKE.Stage_KeepRendering(swigCPtr, durationSeconds);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- }
-
- internal KeyEventSignal KeyEventSignal()
- {
- KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal EventProcessingFinishedSignal()
- {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal TouchSignal TouchSignal()
- {
- TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal StageWheelSignal WheelEventSignal()
- {
- StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal ContextLostSignal()
- {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal ContextRegainedSignal()
- {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- internal VoidSignal SceneCreatedSignal()
- {
- VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(swigCPtr), false);
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
-
- }
-
-}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
namespace Tizen.NUI
{
-
+ using Tizen.NUI.BaseComponents;
/// <summary>
/// TableView is a layout container for aligning child actors in a grid like layout.<br>
/// TableView constrains the x and y position and width and height of the child actors.<br>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~ChildProperty()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
~CellPosition()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// <param name="child">The child to add</param>
/// <param name="position">The position for the child</param>
/// <returns>Tue if the addition succeeded and false if the cell is already occupied</returns>
- public bool AddChild(Actor child, TableView.CellPosition position)
+ public bool AddChild(View child, TableView.CellPosition position)
{
- bool ret = NDalicPINVOKE.TableView_AddChild(swigCPtr, Actor.getCPtr(child), TableView.CellPosition.getCPtr(position));
+ bool ret = NDalicPINVOKE.TableView_AddChild(swigCPtr, View.getCPtr(child), TableView.CellPosition.getCPtr(position));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// </summary>
/// <param name="position">The position in the table</param>
/// <returns>Child that was in the cell or an uninitialized handle</returns>
- public Actor GetChildAt(TableView.CellPosition position)
+ public View GetChildAt(TableView.CellPosition position)
{
- Actor ret = new Actor(NDalicPINVOKE.TableView_GetChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
+ View ret = new View(NDalicPINVOKE.TableView_GetChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// </summary>
/// <param name="position">The position for the child to remove</param>
/// <returns>Child that was removed or an uninitialized handle</returns>
- public Actor RemoveChildAt(TableView.CellPosition position)
+ public View RemoveChildAt(TableView.CellPosition position)
{
- Actor ret = new Actor(NDalicPINVOKE.TableView_RemoveChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
+ View ret = new View(NDalicPINVOKE.TableView_RemoveChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// <param name="child">The child to search for</param>
/// <param name="position">The position for the child</param>
/// <returns>true if the child was included in this TableView</returns>
- public bool FindChildPosition(Actor child, TableView.CellPosition position)
+ public bool FindChildPosition(View child, TableView.CellPosition position)
{
- bool ret = NDalicPINVOKE.TableView_FindChildPosition(swigCPtr, Actor.getCPtr(child), TableView.CellPosition.getCPtr(position));
+ bool ret = NDalicPINVOKE.TableView_FindChildPosition(swigCPtr, View.getCPtr(child), TableView.CellPosition.getCPtr(position));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void DeleteRow(uint rowIndex, ActorContainer removed)
+ internal void DeleteRow(uint rowIndex, ViewContainer removed)
{
- NDalicPINVOKE.TableView_DeleteRow__SWIG_1(swigCPtr, rowIndex, ActorContainer.getCPtr(removed));
+ NDalicPINVOKE.TableView_DeleteRow__SWIG_1(swigCPtr, rowIndex, ViewContainer.getCPtr(removed));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void DeleteColumn(uint columnIndex, ActorContainer removed)
+ internal void DeleteColumn(uint columnIndex, ViewContainer removed)
{
- NDalicPINVOKE.TableView_DeleteColumn__SWIG_1(swigCPtr, columnIndex, ActorContainer.getCPtr(removed));
+ NDalicPINVOKE.TableView_DeleteColumn__SWIG_1(swigCPtr, columnIndex, ViewContainer.getCPtr(removed));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void Resize(uint rows, uint columns, ActorContainer removed)
+ internal void Resize(uint rows, uint columns, ViewContainer removed)
{
- NDalicPINVOKE.TableView_Resize__SWIG_1(swigCPtr, rows, columns, ActorContainer.getCPtr(removed));
+ NDalicPINVOKE.TableView_Resize__SWIG_1(swigCPtr, rows, columns, ViewContainer.getCPtr(removed));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
namespace Tizen.NUI
{
+ using Tizen.NUI.BaseComponents;
/// <summary>
/// Touch events are a collection of points at a specific moment in time.<br>
/// When a multi-touch event occurs, each point represents the points that are currently being
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The actor that was underneath the point specified</returns>
- public Actor GetHitActor(uint point)
+ public View GetHitView(uint point)
{
- Actor ret = new Actor(NDalicPINVOKE.Touch_GetHitActor(swigCPtr, point), true);
+ View ret = new View(NDalicPINVOKE.Touch_GetHitActor(swigCPtr, point), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
}
- /// <summary>
+ /// <summary>
/// To make PushButton instance be disposed.
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetButtonImage(Actor image)
+ internal void SetButtonImage(View image)
{
- NDalicPINVOKE.PushButton_SetButtonImage__SWIG_1(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetButtonImage__SWIG_1(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetBackgroundImage(Actor image)
+ internal void SetBackgroundImage(View image)
{
- NDalicPINVOKE.PushButton_SetBackgroundImage(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetBackgroundImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetSelectedImage(Actor image)
+ internal void SetSelectedImage(View image)
{
- NDalicPINVOKE.PushButton_SetSelectedImage__SWIG_1(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetSelectedImage__SWIG_1(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetSelectedBackgroundImage(Actor image)
+ internal void SetSelectedBackgroundImage(View image)
{
- NDalicPINVOKE.PushButton_SetSelectedBackgroundImage(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetSelectedBackgroundImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetDisabledBackgroundImage(Actor image)
+ internal void SetDisabledBackgroundImage(View image)
{
- NDalicPINVOKE.PushButton_SetDisabledBackgroundImage(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetDisabledBackgroundImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetDisabledImage(Actor image)
+ internal void SetDisabledImage(View image)
{
- NDalicPINVOKE.PushButton_SetDisabledImage(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetDisabledImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetDisabledSelectedImage(Actor image)
+ internal void SetDisabledSelectedImage(View image)
{
- NDalicPINVOKE.PushButton_SetDisabledSelectedImage(swigCPtr, Actor.getCPtr(image));
+ NDalicPINVOKE.PushButton_SetDisabledSelectedImage(swigCPtr, View.getCPtr(image));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
return ret;
}
- internal void SetScrollPropertySource(Handle handle, int propertyScrollPosition, int propertyMinScrollPosition, int propertyMaxScrollPosition, int propertyScrollContentSize)
+ internal void SetScrollPropertySource(Animatable handle, int propertyScrollPosition, int propertyMinScrollPosition, int propertyMaxScrollPosition, int propertyScrollContentSize)
{
- NDalicPINVOKE.ScrollBar_SetScrollPropertySource(swigCPtr, Handle.getCPtr(handle), propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
+ NDalicPINVOKE.ScrollBar_SetScrollPropertySource(swigCPtr, Animatable.getCPtr(handle), propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal void SetScrollIndicator(Actor indicator)
+ internal void SetScrollIndicator(View indicator)
{
- NDalicPINVOKE.ScrollBar_SetScrollIndicator(swigCPtr, Actor.getCPtr(indicator));
+ NDalicPINVOKE.ScrollBar_SetScrollIndicator(swigCPtr, View.getCPtr(indicator));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- internal Actor GetScrollIndicator()
+ internal View GetScrollIndicator()
{
- Actor ret = new Actor(NDalicPINVOKE.ScrollBar_GetScrollIndicator(swigCPtr), true);
+ View ret = new View(NDalicPINVOKE.ScrollBar_GetScrollIndicator(swigCPtr), true);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
~Property()
{
- Dispose();
+ DisposeQueue.Instance.Add(this);
}
public virtual void Dispose()
{
+ if (!Window.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
lock (this)
{
if (swigCPtr.Handle != global::System.IntPtr.Zero)
/// <summary>
/// Sets whether the actor should be focusable by keyboard navigation.<br>
- /// Visuals reuse geometry, shader etc. across controls. They ensure that the renderer and texture sets exist only when control is on-stage.<br>
+ /// Visuals reuse geometry, shader etc. across controls. They ensure that the renderer and texture sets exist only when control is on-window.<br>
/// Each visual also responds to actor size and color change, and provides clipping at the renderer level.<br>
/// </summary>
public class VisualBase : BaseHandle
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// <summary>
/// Return the natural size of the visual.<br>
/// Deriving classes stipulate the natural size and by default a visual has a ZERO natural size.<br>
- /// A visual may not actually have a natural size until it has been placed on stage and acquired all it's resources.<br>
+ /// A visual may not actually have a natural size until it has been placed on window and acquired all it's resources.<br>
/// </summary>
/// <param name="naturalSize">The visual's natural size</param>
public void GetNaturalSize(Size2D naturalSize)
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
/// The wheel event structure is used to store a wheel rolling, it facilitates processing of the wheel rolling and passing to other libraries like Toolkit.<br>
/// There is a key modifier which relates to keys like alt, shift and control functions are supplied to check if they have been pressed when the wheel is being rolled.<br>
/// We support a mouse device and there may be another custom device that support the wheel event. The device type is specified as \e type.<br>
- /// The mouse wheel event can be sent to the specific actor but the custom wheel event will be sent to the stage.<br>
+ /// The mouse wheel event can be sent to the specific actor but the custom wheel event will be sent to the window.<br>
/// </summary>
public class Wheel : global::System.IDisposable
{
public virtual void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
using System;
using System.Runtime.InteropServices;
-
+ using Tizen.NUI.BaseComponents;
/// <summary>
/// The window class is used internally for drawing.<br>
public class Window : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ private global::System.Runtime.InteropServices.HandleRef stageCPtr;
internal Window(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Window_SWIGUpcast(cPtr), cMemoryOwn)
{
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ stageCPtr = new global::System.Runtime.InteropServices.HandleRef(this, NDalicPINVOKE.Stage_GetCurrent());
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Window obj)
/// </summary>
public override void Dispose()
{
- if (!Stage.IsInstalled())
+ if (!Window.IsInstalled())
{
DisposeQueue.Instance.Add(this);
return;
{
swigCMemOwn = false;
NDalicPINVOKE.delete_Window(swigCPtr);
+ NDalicPINVOKE.delete_Stage(stageCPtr);
}
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
}
}
}
+ internal static Window GetCurrent()
+ {
+ Window ret = new Window(NDalicPINVOKE.Stage_GetCurrent(), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal static bool IsInstalled()
+ {
+ bool ret = NDalicPINVOKE.Stage_IsInstalled();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
/// <summary>
/// Sets the focus acceptable flag of an window as true.
/// </summary>
{
_windowFocusChangedEventHandler -= value;
- if (_windowFocusChangedEventHandler == null && WindowFocusChangedSignal().Empty() == false)
+ if (_windowFocusChangedEventHandler == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback != null)
{
WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback);
}
}
}
- public WindowFocusSignalType WindowFocusChangedSignal()
+ internal WindowFocusSignalType WindowFocusChangedSignal()
{
WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ internal WindowFocusSignalType FocusChangedSignal()
+ {
+ WindowFocusSignalType ret = new WindowFocusSignalType(NDalicPINVOKE.FocusChangedSignal(swigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Get default ( root ) layer.
+ /// </summary>
+ /// <returns>The root layer</returns>
+ public Layer GetDefaultLayer()
+ {
+ return this.GetRootLayer();
+ }
+
+ /// <summary>
+ /// Add layer to the Stage.
+ /// </summary>
+ /// <param name="layer">Layer to add</param>
+ public void AddLayer(Layer layer)
+ {
+ NDalicPINVOKE.Stage_Add(stageCPtr, Layer.getCPtr(layer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ /// <summary>
+ /// Remove layer from the Stage.
+ /// </summary>
+ /// <param name="layer">Layer to remove</param>
+ public void RemoveLayer(Layer layer)
+ {
+ NDalicPINVOKE.Stage_Remove(stageCPtr, Layer.getCPtr(layer));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void Add(View view)
+ {
+ NDalicPINVOKE.Stage_Add(stageCPtr, View.getCPtr(view));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal void Remove(View view)
+ {
+ NDalicPINVOKE.Stage_Remove(stageCPtr, View.getCPtr(view));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector2 GetSize()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal RenderTaskList GetRenderTaskList()
+ {
+ RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal uint GetLayerCount()
+ {
+ uint ret = NDalicPINVOKE.Stage_GetLayerCount(stageCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public Layer GetLayer(uint depth)
+ {
+ Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(stageCPtr, depth), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Layer GetRootLayer()
+ {
+ Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal void SetBackgroundColor(Vector4 color)
+ {
+ NDalicPINVOKE.Stage_SetBackgroundColor(stageCPtr, Vector4.getCPtr(color));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal Vector4 GetBackgroundColor()
+ {
+ Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal Vector2 GetDpi()
+ {
+ Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal ObjectRegistry GetObjectRegistry()
+ {
+ ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(stageCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ /// <summary>
+ /// Keep rendering for at least the given amount of time.
+ /// </summary>
+ /// <param name="durationSeconds">Time to keep rendering, 0 means render at least one more frame</param>
+ public void KeepRendering(float durationSeconds)
+ {
+ NDalicPINVOKE.Stage_KeepRendering(stageCPtr, durationSeconds);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ internal KeyEventSignal KeyEventSignal()
+ {
+ KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal VoidSignal EventProcessingFinishedSignal()
+ {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal TouchSignal TouchSignal()
+ {
+ TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private StageWheelSignal WheelEventSignal()
+ {
+ StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal VoidSignal ContextLostSignal()
+ {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal VoidSignal ContextRegainedSignal()
+ {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal VoidSignal SceneCreatedSignal()
+ {
+ VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(stageCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal static Vector4 DEFAULT_BACKGROUND_COLOR
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
+ Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Vector4 DEBUG_BACKGROUND_COLOR
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
+ Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ private static readonly Window instance = Application.Instance.GetWindow();
+
+ /// <summary>
+ /// Stage instance property (read-only).<br>
+ /// Gets the current Window.<br>
+ /// </summary>
+ public static Window Instance
+ {
+ get
+ {
+ return instance;
+ }
+ }
+
/// <summary>
/// Grabs the key specified by a key for a window only when a window is the topmost window. <br>
/// This function can be used for following example scenarios: <br>
Visible = 1,
Auto = 2
}
+
+ /// <summary>
+ /// Touch event argument.
+ /// </summary>
+ public class TouchEventArgs : EventArgs
+ {
+ private Touch _touch;
+
+ /// <summary>
+ /// Touch.
+ /// </summary>
+ public Touch Touch
+ {
+ get
+ {
+ return _touch;
+ }
+ set
+ {
+ _touch = value;
+ }
+ }
+ }
+
+ private event EventHandler<TouchEventArgs> _stageTouchHandler;
+ private EventCallbackDelegateType1 _stageTouchCallbackDelegate;
+
+ /// <summary>
+ /// This is emitted when the screen is touched and when the touch ends.<br>
+ /// If there are multiple touch points, then this will be emitted when the first touch occurs and
+ /// then when the last finger is lifted.<br>
+ /// An interrupted event will also be emitted (if it occurs).<br>
+ /// </summary>
+ public event EventHandler<TouchEventArgs> TouchEvent
+ {
+ add
+ {
+ lock (this)
+ {
+ _stageTouchHandler += value;
+ _stageTouchCallbackDelegate = OnStageTouch;
+ this.TouchSignal().Connect(_stageTouchCallbackDelegate);
+ }
+ }
+ remove
+ {
+ lock (this)
+ {
+ if (_stageTouchHandler != null)
+ {
+ this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
+ }
+ _stageTouchHandler -= value;
+ }
+ }
+ }
+
+ private void OnStageTouch(IntPtr data)
+ {
+ TouchEventArgs e = new TouchEventArgs();
+
+ if (data != null)
+ {
+ e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(data);
+ }
+
+ if (_stageTouchHandler != null)
+ {
+ _stageTouchHandler(this, e);
+ }
+ }
+
+ /// <summary>
+ /// Wheel event arguments.
+ /// </summary>
+ public class WheelEventArgs : EventArgs
+ {
+ private Wheel _wheel;
+
+ /// <summary>
+ /// Wheel.
+ /// </summary>
+ public Wheel Wheel
+ {
+ get
+ {
+ return _wheel;
+ }
+ set
+ {
+ _wheel = value;
+ }
+ }
+ }
+
+ private event EventHandler<WheelEventArgs> _stageWheelHandler;
+ private EventCallbackDelegateType1 _stageWheelCallbackDelegate;
+
+ /// <summary>
+ /// Event emitted when wheel event is received.
+ /// </summary>
+ public event EventHandler<WheelEventArgs> WheelEvent
+ {
+ add
+ {
+ if (_stageWheelHandler == null)
+ {
+ _stageWheelCallbackDelegate = OnStageWheel;
+ WheelEventSignal().Connect(_stageWheelCallbackDelegate);
+ }
+ _stageWheelHandler += value;
+ }
+ remove
+ {
+ _stageWheelHandler -= value;
+ if (_stageWheelHandler == null && WheelEventSignal().Empty() == false)
+ {
+ WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
+ }
+ }
+ }
+
+ private void OnStageWheel(IntPtr data)
+ {
+ WheelEventArgs e = new WheelEventArgs();
+
+ if (data != null)
+ {
+ e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(data);
+ }
+
+ if (_stageWheelHandler != null)
+ {
+ _stageWheelHandler(this, e);
+ }
+ }
+
+ /// <summary>
+ /// Key event arguments.
+ /// </summary>
+ public class KeyEventArgs : EventArgs
+ {
+ private Key _key;
+
+ /// <summary>
+ /// Key
+ /// </summary>
+ public Key Key
+ {
+ get
+ {
+ return _key;
+ }
+ set
+ {
+ _key = value;
+ }
+ }
+ }
+
+ private event EventHandler<KeyEventArgs> _stageKeyHandler;
+ private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
+
+ /// <summary>
+ /// Event emitted when key event is received.
+ /// </summary>
+ public event EventHandler<KeyEventArgs> KeyEvent
+ {
+ add
+ {
+ if (_stageKeyHandler == null)
+ {
+ _stageKeyCallbackDelegate = OnStageKey;
+ KeyEventSignal().Connect(_stageKeyCallbackDelegate);
+ }
+ _stageKeyHandler += value;
+ }
+ remove
+ {
+ _stageKeyHandler -= value;
+ if (_stageKeyHandler == null && KeyEventSignal().Empty() == false)
+ {
+ KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
+ }
+ }
+ }
+
+ // Callback for Stage KeyEventsignal
+ private void OnStageKey(IntPtr data)
+ {
+ KeyEventArgs e = new KeyEventArgs();
+
+ if (data != null)
+ {
+ e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
+ }
+
+ if (_stageKeyHandler != null)
+ {
+ //here we send all data to user event handlers
+ _stageKeyHandler(this, e);
+ }
+ }
+
+
+ private event EventHandler _stageEventProcessingFinishedEventHandler;
+ private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
+
+ internal event EventHandler EventProcessingFinished
+ {
+ add
+ {
+ if (_stageEventProcessingFinishedEventHandler == null)
+ {
+ _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
+ EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
+ }
+ _stageEventProcessingFinishedEventHandler += value;
+
+ }
+ remove
+ {
+ _stageEventProcessingFinishedEventHandler -= value;
+ if (_stageEventProcessingFinishedEventHandler == null && EventProcessingFinishedSignal().Empty() == false)
+ {
+ EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
+ }
+ }
+ }
+
+ // Callback for Stage EventProcessingFinishedSignal
+ private void OnEventProcessingFinished()
+ {
+ if (_stageEventProcessingFinishedEventHandler != null)
+ {
+ _stageEventProcessingFinishedEventHandler(this, null);
+ }
+ }
+
+
+ private EventHandler _stageContextLostEventHandler;
+ private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
+
+ internal event EventHandler ContextLost
+ {
+ add
+ {
+ if (_stageContextLostEventHandler == null)
+ {
+ _stageContextLostEventCallbackDelegate = OnContextLost;
+ ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
+ }
+ _stageContextLostEventHandler += value;
+ }
+ remove
+ {
+ _stageContextLostEventHandler -= value;
+ if (_stageContextLostEventHandler == null && ContextLostSignal().Empty() == false)
+ {
+ ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
+ }
+ }
+ }
+
+ // Callback for Stage ContextLostSignal
+ private void OnContextLost()
+ {
+ if (_stageContextLostEventHandler != null)
+ {
+ _stageContextLostEventHandler(this, null);
+ }
+ }
+
+
+ private EventHandler _stageContextRegainedEventHandler;
+ private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
+
+ internal event EventHandler ContextRegained
+ {
+ add
+ {
+ if (_stageContextRegainedEventHandler == null)
+ {
+ _stageContextRegainedEventCallbackDelegate = OnContextRegained;
+ ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
+ }
+ _stageContextRegainedEventHandler += value;
+ }
+ remove
+ {
+ _stageContextRegainedEventHandler -= value;
+ if (_stageContextRegainedEventHandler == null && ContextRegainedSignal().Empty() == false)
+ {
+ this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
+ }
+ }
+ }
+
+ // Callback for Stage ContextRegainedSignal
+ private void OnContextRegained()
+ {
+ if (_stageContextRegainedEventHandler != null)
+ {
+ _stageContextRegainedEventHandler(this, null);
+ }
+ }
+
+
+ private EventHandler _stageSceneCreatedEventHandler;
+ private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
+
+ internal event EventHandler SceneCreated
+ {
+ add
+ {
+ if (_stageSceneCreatedEventHandler == null)
+ {
+ _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
+ SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
+ }
+ _stageSceneCreatedEventHandler += value;
+ }
+ remove
+ {
+ _stageSceneCreatedEventHandler -= value;
+ if (_stageSceneCreatedEventHandler == null && SceneCreatedSignal().Empty() == false)
+ {
+ SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
+ }
+ }
+ }
+
+ // Callback for Stage SceneCreatedSignal
+ private void OnSceneCreated()
+ {
+ if (_stageSceneCreatedEventHandler != null)
+ {
+ _stageSceneCreatedEventHandler(this, null);
+ }
+ }
+
+ /// <summary>
+ /// Window size property (read-only).
+ /// </summary>
+ public Vector2 Size
+ {
+ get
+ {
+ Vector2 ret = GetSize();
+ return ret;
+ }
+ }
+
+ /// <summary>
+ /// Background color property.
+ /// </summary>
+ public Vector4 BackgroundColor
+ {
+ set
+ {
+ SetBackgroundColor(value);
+ }
+ get
+ {
+ Vector4 ret = GetBackgroundColor();
+ return ret;
+ }
+ }
+
+ /// <summary>
+ /// Dpi property (read-only).<br>
+ /// Retrieves the DPI of the display device to which the Window is connected.<br>
+ /// </summary>
+ public Vector2 Dpi
+ {
+ get
+ {
+ return GetDpi();
+ }
+ }
+
+ /// <summary>
+ /// Layer count property (read-only).<br>
+ /// Queries the number of on-Window layers.<br>
+ /// </summary>
+ public uint LayerCount
+ {
+ get
+ {
+ return GetLayerCount();
+ }
+ }
}
}
projects / platform / core / csapi / tizenfx.git / commitdiff