-/** 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 />
+// 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 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.
-//------------------------------------------------------------------------------
+// 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.
+ /// UI controls can be built by combining multiple actors.
+ /// </summary>
public class Actor : Handle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make Actor instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
return (IntPtr)swigCPtr;
}
+ /// <summary>
+ /// Retrieve the position of the Actor.
+ /// The coordinates are relative to the Actor's parent.
+ /// </summary>
public Position CurrentPosition
{
get
return GetCurrentPosition();
}
}
+
+ /// <summary>
+ /// Retrieve the size of the Actor.
+ /// The coordinates are relative to the Actor's parent.
+ /// </summary>
public Size CurrentSize
{
get
}
}
+ /// <summary>
+ /// Retrieves the actor's parent.
+ /// </summary>
public Actor Parent
{
get
}
}
+ /// <summary>
+ /// Retrieves and sets the actor's opacity.
+ /// </summary>
public float Opacity
{
get
}
}
+ /// <summary>
+ /// Retrieves screen postion of actor's
+ /// </summary>
public Vector2 ScreenPosition
{
get
}
}
+ /// <summary>
+ /// Determines whether the anchor point should be used to determine the position of the actor.
+ /// This is true by default.
+ /// Note: 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.
+ /// </summary>
public bool PositionUsesAnchorPoint
{
get
}
}
+ /// <summary>
+ /// Queries whether the actor is connected to the Stage.
+ /// When an actor is connected, it will be directly or indirectly parented to the root Actor.
+ /// </summary>
public bool IsOnStage
{
get
}
}
+ /// <summary>
+ /// Gets depth in the hierarchy for the actor.
+ /// </summary>
public int HierarchyDepth
{
get
}
}
+ /// <summary>
+ /// Sets the sibling order of the actor so depth position can be defined within the same parent.
+ /// 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.
+ /// </summary>
public int SiblingOrder
{
get
}
}
+ /// <summary>
+ /// Sets the size of an actor for Width and Height.
+ /// Geometry can be scaled to fit within this area.
+ /// This does not interfere with the actors scale factor.
+ /// The actors default depth is the minimum of Width & Height.
+ /// </summary>
public Size2D Size2D
{
get
}
}
+ /// <summary>
+ /// Sets the position of the Actor for X and Y.
+ /// By default, sets the position vector between the parent origin and anchor point(default).
+ /// If Position inheritance if disabled, sets the world position.
+ /// </summary>
public Position2D Position2D
{
get
}
}
-
+ /// <summary>
+ /// Sets the visibility flag of an actor as true to be shown.
+ /// Note This is an asynchronous method; the value written may not match a value subsequently read with Visible.
+ /// If an actor's visibility flag is set to false, 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.
+ /// </summary>
public void Show()
{
SetVisible(true);
}
+ /// <summary>
+ /// Sets the visibility flag of an actor as false to be hidden.
+ /// </summary>
public void Hide()
{
SetVisible(false);
}
+ /// <summary>
+ /// Raise actor above the next highest level of actor(s).
+ /// Note 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.
+ /// </summary>
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).
+ /// Note 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.
+ /// </summary>
public void Lower()
{
NDalicPINVOKE.Lower(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Raise actor above all other actors.
+ /// Note 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.
+ /// </summary>
public void RaiseToTop()
{
NDalicPINVOKE.RaiseToTop(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Lower actor to the bottom of all actors.
+ /// Note 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.
+ /// </summary>
public void LowerToBottom()
{
NDalicPINVOKE.LowerToBottom(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Raise the actor to above the target actor.
+ /// Note 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.
+ /// </summary>
+ /// <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.
+ /// Note 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.
+ /// </summary>
+ /// <param name="target">Will be lowered below this actor</param>
public void LowerBelow(Actor target)
{
NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
}
+ /// <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.
+ /// If handle points to an Actor object, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized. *
+ /// </summary>
+ /// <param name="handle">handle to An object</param>
+ /// <returns>handle to a 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);
return ret;
}
+ /// <summary>
+ /// Adds a child Actor to this Actor.
+ /// Precondition : This Actor(the parent) has been initialized. The child actor has been initialized. The child actor is not the same as the parent actor.
+ /// PostCondition : 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.
+ /// Note : 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.
+ /// </summary>
+ /// <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.
+ /// Precondition : This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.
+ /// </summary>
+ /// <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();
}
+ /// <summary>
+ /// Retrieves the number of children held by the actor.
+ /// Precondition : The Actor has been initialized.
+ /// </summary>
+ /// <returns>The number of children</returns>
public uint GetChildCount()
{
uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Retrieve and child actor by index.
+ /// Precondition : The Actor has been initialized.
+ /// </summary>
+ /// <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);
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.
+ ///Precondition : The Actor has been initialized.
+ /// </summary>
+ /// <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);
return ret;
}
+ /// <summary>
+ /// Returns the natural size of the actor.
+ /// Deriving classes stipulate the natural size and by default an actor has a ZERO natural size.
+ /// </summary>
+ /// <returns>The actor's natural size</returns>
public Vector3 GetNaturalSize()
{
Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
return ret;
}
+ /// <summary>
+ /// Converts screen coordinates into the actor's coordinate system using the default camera.
+ /// Precondition : The Actor has been initialized.
+ /// Note : The actor coordinates are relative to the top-left(0.0, 0.0, 0.5)
+ /// </summary>
+ /// <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);
return ret;
}
+ /// <summary>
+ /// Sets the relative to parent size factor of the actor.
+ /// This factor is only used when ResizePolicy is set to either
+ /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicy
+ /// Precondition : The Actor has been initialized.
+ /// </summary>
+ /// <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));
return ret;
}
+ /// <summary>
+ /// Calculates the height of the actor given a width.
+ /// The natural size is used for default calculation.
+ /// size 0 is treated as aspect ratio 1:1.
+ /// </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);
return ret;
}
+ /// <summary>
+ /// Calculates the width of the actor given a height.
+ /// The natural size is used for default calculation.
+ /// size 0 is treated as aspect ratio 1:1.
+ /// </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);
return ret;
}
+ /// <summary>
+ /// Sets the padding for use in layout.
+ /// </summary>
+ /// <param name="padding">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.
+ /// </summary>
+ /// <param name="paddingOut">The returned padding data</param>
public void GetPadding(PaddingType paddingOut)
{
NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
return ret;
}
+ /// <summary>
+ /// Gets/Sets the origin of an actor, within its parent's area.
+ /// 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.
+ /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).
+ /// An actor's position is the distance between this origin, and the actor's anchor-point.
+ /// Precondition : The Actor has been initialized.
+ /// </summary>
public Position ParentOrigin
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the anchor-point of an actor.
+ /// 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.
+ /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).
+ /// An actor position is the distance between its parent-origin and this anchor-point.
+ /// An actor's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.
+ /// Precondition : The Actor has been initialized.
+ /// </summary>
public Position AnchorPoint
{
get
SetProperty(Actor.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
}
}
+
+
+ /// <summary>
+ /// Gets/Sets the size of an actor.
+ /// Geometry can be scaled to fit within this area.
+ /// This does not interfere with the actors scale factor.
+ /// </summary>
public Size Size
{
get
SetProperty(Actor.Property.SIZE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the size width of an actor.
+ /// </summary>
public float SizeWidth
{
get
SetProperty(Actor.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the size height of an actor.
+ /// </summary>
public float SizeHeight
{
get
SetProperty(Actor.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the size depth of an actor.
+ /// </summary>
public float SizeDepth
{
get
SetProperty(Actor.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the position of the Actor.
+ /// By default, sets the position vector between the parent origin and anchor point(default).
+ /// If Position inheritance if disabled, sets the world position.
+ /// </summary>
public Position Position
{
get
SetProperty(Actor.Property.POSITION, new Tizen.NUI.PropertyValue(value));
}
}
+
+
+ /// <summary>
+ /// Gets/Sets the position x of the Actor.
+ /// </summary>
public float PositionX
{
get
SetProperty(Actor.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the position y of the Actor.
+ /// </summary>
public float PositionY
{
get
SetProperty(Actor.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the position z of the Actor.
+ /// </summary>
public float PositionZ
{
get
SetProperty(Actor.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the world position of the Actor.
+ /// </summary>
public Vector3 WorldPosition
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the orientation of the Actor.
+ /// An actor's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.
+ /// Note: This is an asynchronous method.
+ /// </summary>
public Rotation Orientation
{
get
SetProperty(Actor.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the world orientation of the Actor.
+ /// </summary>
public Rotation WorldOrientation
{
get
return temp;
}
}
+
+ /// <summary>
+ /// Gets/Sets the scale factor applied to an actor.
+ /// Note : This is an asynchronous method.
+ /// </summary>
public Vector3 Scale
{
get
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
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
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
SetProperty(Actor.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets the world scale of Actor.
+ /// </summary>
public Vector3 WorldScale
{
get
return temp;
}
}
+
+ /// <summary>
+ /// Retrieves the visibility flag of an actor.
+ /// Note : 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.
+ /// </summary>
public bool Visible
{
get
}
*/
}
+
+ /// <summary>
+ /// Gets/Sets the actor's mix color; this is an RGBA value.
+ /// The final color of the actor depends on its color mode.
+ /// Note : This is an asynchronous method.
+ /// </summary>
public Color MixColor
{
get
SetProperty(Actor.Property.COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the actor's mix color red.
+ /// </summary>
public float ColorRed
{
get
SetProperty(Actor.Property.COLOR_RED, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the actor's mix color green.
+ /// </summary>
public float ColorGreen
{
get
SetProperty(Actor.Property.COLOR_GREEN, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the actor's mix color blue
+ /// </summary>
public float ColorBlue
{
get
SetProperty(Actor.Property.COLOR_BLUE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the actor's mix color alpha.
+ /// </summary>
public float ColorAlpha
{
get
SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets the actor's world color.
+ /// </summary>
public Color WorldColor
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the Actor's name.
+ /// </summary>
public string Name
{
get
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
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
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
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
}
}
+ /// <summary>
+ /// Gets/Sets the actor's color mode.
+ /// This specifies whether the Actor uses its own color, or inherits its parent color.
+ /// The default is UseOwnMultiplyParentAlpha.
+ /// </summary>
public ColorMode ColorMode
{
get
case "USE_OWN_MULTIPLY_PARENT_ALPHA":
return ColorMode.UseOwnMultiplyParentAlpha;
default:
- return ColorMode.UseOwnColor;
+ return ColorMode.UseOwnMultiplyParentAlpha;
}
}
set
}
}
+
+ /// <summary>
+ /// Gets/Sets the status of how the actor and its children should be drawn.
+ /// Not all actors are renderable, but DrawMode can be inherited from any actor.
+ /// 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.
+ /// If DrawMode.Overlay2D is used, the actor and its children will be drawn as a 2D overlay.
+ /// Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.
+ /// For overlay actors, the drawing order is with respect to tree levels of Actors, and depth-testing will not be used.
+ /// </summary>
public DrawModeType DrawMode
{
get
SetProperty(Actor.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the relative to parent size factor of the actor.
+ /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.
+ /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicyType.
+ /// </summary>
public Vector3 SizeModeFactor
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the width resize policy to be used for the given dimension(s).
+ /// </summary>
public ResizePolicyType WidthResizePolicy
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the height resize policy to be used for the given dimension(s).
+ /// </summary>
public ResizePolicyType HeightResizePolicy
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the policy to use when setting size with size negotiation.
+ /// Defaults to SizeScalePolicyType.UseSizeSet.
+ /// </summary>
public SizeScalePolicyType SizeScalePolicy
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the status of whether the width size is dependent on height size.
+ /// </summary>
public bool WidthDependentOnHeight
{
get
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
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
}
}
+
+ /// <summary>
+ /// Gets/Sets the minimum size an actor can be assigned in size negotiation.
+ /// </summary>
public Size2D MinimumSize
{
get
}
}
+
+ /// <summary>
+ /// Gets/Sets the maximum size an actor can be assigned in size negotiation.
+ /// </summary>
public Size2D MaximumSize
{
get
SetProperty(Actor.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets whether a child actor inherits it's parent's position.
+ /// Default is to inherit.
+ /// 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.
+ /// </summary>
public bool InheritPosition
{
get
}
}
+ /// <summary>
+ /// Gets/Sets clipping behavior(mode) of it's children
+ /// </summary>
public ClippingModeType ClippingMode
{
get
}
+ /// <summary>
+ /// This specifies whether the Actor uses its own color, or inherits
+ /// ColorMode.UseOwnColor : Actor will use its own color
+ /// ColorMode.UseParentColor : Actor will use its parent color
+ /// ColorMode.UseOwnMultiplyParentColor : Actor will blend its color with its parents color.
+ /// ColorMode.UseOwnMultiplyParentAlpha : Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default.
+ /// </summary>
public enum ColorMode
{
UseOwnColor,
UseOwnMultiplyParentAlpha
}
+ /// <summary>
+ /// This specifies the dimesion of width or heigh for size negotiation.
+ /// </summary>
public enum DimensionType
{
Width = 0x1,
Height = 0x2,
AllDimensions = 0x3
}
+
+ /// <summary>
+ /// This specifies draw mode types
+ /// </summary>
public enum DrawModeType
{
Normal = 0,
Overlay2D = 1,
Stencil = 3
}
+
+ /// <summary>
+ /// This specifies resize policy types
+ /// </summary>
public enum ResizePolicyType
{
Fixed,
DimensionDependency,
UseAssignedSize
}
+
+ /// <summary>
+ /// This specifies size scale policy types
+ /// </summary>
public enum SizeScalePolicyType
{
UseSizeSet,
FitWithAspectRatio,
FillWithAspectRatio
}
+
+ /// <summary>
+ /// This specifies clipping mode types
+ /// </summary>
public enum ClippingModeType
{
Disabled,
-//------------------------------------------------------------------------------
-// <auto-generated />
+// Copyright (c) 2017 Samsung Electronics Co., Ltd.
//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// 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
//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
+// 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>
+ /// Alpha functions are used in animations to specify the rate of change of the animation parameter over time.
+ /// Understanding an animation as a parametric function over time, the alpha function is applied to the parameter of
+ /// the animation before computing the final animation value.
+ /// </summary>
public class AlphaFunction : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make AlphaFunction instance be disposed.
+ /// </summary>
public virtual void Dispose()
{
if (!Stage.IsInstalled())
}
}
-
+ /// <summary>
+ /// Constructor.
+ /// Creates an alpha function object with user defined alpha function.
+ /// </summary>
+ /// <param name="func">User defined fuction. It must be a method formatted as float alphafunction(float progress)</param>
public AlphaFunction(System.Delegate func) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_2(SWIGTYPE_p_f_float__float.getCPtr(new SWIGTYPE_p_f_float__float(System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func), true))), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Default constructor.
+ /// Creates an alpha function object with the default built-in alpha function.
+ /// </summary>
public AlphaFunction() : this(NDalicPINVOKE.new_AlphaFunction__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// Creates an alpha function object with the built-in alpha function passed as a parameter to the constructor.
+ /// </summary>
+ /// <param name="function">One of the built-in alpha functions</param>
public AlphaFunction(AlphaFunction.BuiltinFunctions function) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_1((int)function), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// Creates a bezier alpha function.The bezier will have the first point at(0,0) and the end point at(1,1).
+ /// Note : The x components of the control points will be clamped to the range[0, 1] to prevent non monotonic curves.
+ /// </summary>
+ /// <param name="controlPoint0">A Vector2 which will be used as the first control point of the curve</param>
+ /// <param name="controlPoint1">A Vector2 which will be used as the second control point of the curve</param>
public AlphaFunction(Vector2 controlPoint0, Vector2 controlPoint1) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_3(Vector2.getCPtr(controlPoint0), Vector2.getCPtr(controlPoint1)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrives the control points of the alpha function.
+ /// </summary>
+ /// <param name="controlPoint0">A Vector2 which is used as the first control point of the curve</param>
+ /// <param name="controlPoint1">A Vector2 which is used as the second control point of the curve</param>
public void GetBezierControlPoints(out Vector2 controlPoint0, out Vector2 controlPoint1)
{
Vector4 ret = new Vector4(NDalicPINVOKE.AlphaFunction_GetBezierControlPoints(swigCPtr), true);
return ret;
}
+ /// <summary>
+ /// Returns the built-in function used by the alpha function.
+ /// In case no built-in function has been specified, it will return AlphaFunction::DEFAULT
+ /// </summary>
+ /// <returns>One of the built-in alpha functions.</returns>
public AlphaFunction.BuiltinFunctions GetBuiltinFunction()
{
AlphaFunction.BuiltinFunctions ret = (AlphaFunction.BuiltinFunctions)NDalicPINVOKE.AlphaFunction_GetBuiltinFunction(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the functioning mode of the alpha function
+ /// </summary>
+ /// <returns>The functioning mode of the alpha function</returns>
public AlphaFunction.Modes GetMode()
{
AlphaFunction.Modes ret = (AlphaFunction.Modes)NDalicPINVOKE.AlphaFunction_GetMode(swigCPtr);
return ret;
}
+ /// <summary>
+ /// This specifies the various types of BuiltinFunctions
+ /// </summary>
public enum BuiltinFunctions
{
Default,
Count
}
+ /// <summary>
+ /// This specifies which mode is set for AlphaFuction
+ /// </summary>
public enum Modes
{
CustomFunction = 1,
-/** 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 />
+// 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
//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// 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.
//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
+//
+// 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>
+ /// Animation can be used to animate the properties of any number of objects, typically Actors.
+ /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.
+ /// This is typically done in the object destructor, and requires either the Animation handle to be stored.
+ /// The overall animation time is superseded by the values given in the Duration property used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.
+ /// If any of the individual calls to those functions exceeds the overall animation time(Duration), then the overall animation time is automatically extended.
+ /// </summary>
public class Animation : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make Animation instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
}
-
-
- /**
- * @brief Create an initialized Animation.
- *
- * The animation will not loop.
- * The default end action is "Bake".
- * The default Alpha function is linear.
- * @since 1.0.0
- * @param [in] durationmSeconds The duration in milli seconds (int).
- * @return A handle to a newly allocated Dali resource.
- * @pre DurationmSeconds must be greater than zero.
- */
+ /// <summary>
+ /// Create an initialized Animation.
+ /// The animation will not loop.
+ /// The default end action is "Cancel".
+ /// The default Alpha function is linear.
+ /// Precodition : DurationmSeconds must be greater than zero.
+ /// </summary>
+ /// <param name="durationMilliSeconds">The duration in milli seconds (int).</param>
public Animation(int durationMilliSeconds) : this(NDalicPINVOKE.Animation_New((float)durationMilliSeconds / 1000.0f), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return (int)(sec * 1000);
}
+
+ /// <summary>
+ /// Gets/Sets the duration of animation
+ /// </summary>
public int Duration
{
set
}
}
+ /// <summary>
+ /// Gets/Sets the default alpha function for an animation.
+ /// </summary>
public AlphaFunction DefaultAlphaFunction
{
set
}
}
+ /// <summary>
+ /// Queries the state of the animation.
+ /// </summary>
public States State
{
get
}
}
+ /// <summary>
+ /// Set : Enables looping for 'count' repeats. A zero is the same as Looping = true; i.e.repeat forever.
+ /// If Play() Stop() or 'count' loops is reached, the loop counter will reset.
+ /// Setting this parameter does not cause the animation to Play().
+ ///
+ /// Get : Gets the loop count. A zero is the same as Looping = true; ie repeat forever.
+ /// The loop count is initially 1 for play once.
+ /// </summary>
public int LoopCount
{
set
}
}
+ /// <summary>
+ /// Gets/Sets the status of whether the animation will loop.
+ /// This property resets the loop count and should not be used with LoopCount property.
+ /// Setting this parameter does not cause the animation to Play().
+ /// </summary>
public bool Looping
{
set
}
}
+
+ /// <summary>
+ /// Gets/Sets the end action of the animation.
+ /// This action is performed when the animation ends or if it is stopped.
+ /// Default end action is Cancel
+ /// </summary>
public EndActions EndAction
{
set
}
}
+
+ /// <summary>
+ /// Stops the animation.
+ /// </summary>
+ /// <param name="action">end action can be set</param>
public void Stop(EndActions action = EndActions.Cancel)
{
SetEndAction(action);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Gets the current loop count.
+ /// A value 0 to CurrentLoop indicating the current loop count when looping.
+ /// </summary>
public int CurrentLoop
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the disconnect action.
+ /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.
+ /// Default action is to Cancel.
+ /// </summary>
public EndActions DisconnectAction
{
set
}
}
+
+ /// <summary>
+ /// Gets/Sets the progress of the animation.
+ /// The animation will play(or continue playing) from this point.
+ /// The progress must be in the 0-1 interval or in the play range interval if defined
+ /// otherwise, it will be ignored.
+ /// </summary>
public float CurrentProgress
{
set
}
}
+ /// <summary>
+ /// Gets/Sets Specifies a speed factor for the animation.
+ /// The speed factor is a multiplier of the normal velocity of the animation.
+ /// Values between[0, 1] will slow down the animation and values above one will speed up the animation.
+ /// It is also possible to specify a negative multiplier to play the animation in reverse.
+ /// </summary>
public float SpeedFactor
{
set
}
}
+ /// <summary>
+ /// Gets/Sets the playing range.
+ /// Animation will play between the values specified. Both values(range.x and range.y ) should be between 0-1,
+ /// otherwise they will be ignored.If the range provided is not in proper order(minimum, maximum ), it will be reordered.
+ /// </summary>
public Vector2 PlayRange
{
set
}
}
-
+ /// <summary>
+ /// Animates a property value by a relative amount.
+ /// The default alpha function will be used.
+ /// The effect will start & end when the animation begins & ends.
+ /// </summary>
+ /// <param name="target">The target object to animate</param>
+ /// <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)
{
string _str1 = property.Substring(0, 1);
}
}
+ /// <summary>
+ /// Animates a property value by a relative amount.
+ /// The default alpha function will be used.
+ /// The effect will start & end when the animation begins & ends.
+ /// </summary>
+ /// <param name="target">The target object to animate</param>
+ /// <param name="property">The target property to animate</param>
+ /// <param name="relativeValue">The property value will change by this amount</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 AnimateBy(Actor target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
}
}
+ /// <summary>
+ /// Animates a property to a destination value.
+ /// The default alpha function will be used.
+ /// The effect will start & end when the animation begins & ends.
+ /// </summary>
+ /// <param name="target">The target object to animate</param>
+ /// <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)
{
string _str1 = property.Substring(0, 1);
}
}
+ /// <summary>
+ /// Animates a property to a destination value.
+ /// The default alpha function will be used.
+ /// The effect will start & end when the animation begins & ends.
+ /// </summary>
+ /// <param name="target">The target object to animate</param>
+ /// <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>
+ /// <param name="startTime">Start time of animation</param>
+ /// <param name="endTime">End time of animation</param>
+ /// <param name="alphaFunction"></param>
public void AnimateTo(Actor target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
}
}
+ /// <summary>
+ /// Animates a property between keyframes.
+ /// </summary>
+ /// <param name="target">The target object to animate</param>
+ /// <param name="property">The target property to animate</param>
+ /// <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)
{
string _str1 = property.Substring(0, 1);
}
}
+
+ /// <summary>
+ /// Animates a property between keyframes.
+ /// </summary>
+ /// <param name="target">The target object to animate</param>
+ /// <param name="property">The target property to animate</param>
+ /// <param name="keyFrames">The set of time/value pairs between which to animate</param>
+ /// <param name="startTime">Start time of animation</param>
+ /// <param name="endTime">End time of animation</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)
{
string _str1 = property.Substring(0, 1);
}
}
+ /// <summary>
+ /// Animates an actor's position and orientation through a predefined path.
+ /// The actor will rotate to orient the supplied forward vector with the path's tangent.
+ /// If forward is the zero vector then no rotation will happen.
+ /// </summary>
+ /// <param name="actor">The actor 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)
{
if (alphaFunction == null)
}
}
+ /// <summary>
+ /// Animates an actor's position and orientation through a predefined path.
+ /// The actor will rotate to orient the supplied forward vector with the path's tangent.
+ /// If forward is the zero vector then no rotation will happen.
+ /// </summary>
+ /// <param name="actor">The actor 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)
{
TimePeriod time = new TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
}
}
-
+ /// <summary>
+ /// Creates an initialized Animation.
+ /// The animation will not loop.
+ /// The default end action is "Cancel".
+ /// The default alpha function is linear.
+ /// </summary>
public Animation() : this(NDalicPINVOKE.Animation_New(0.0f), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Downcasts a handle to Animation handle.
+ /// If handle points to an Animation object, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to an Animation object or an uninitialized handle</returns>
public static Animation DownCast(BaseHandle handle)
{
Animation ret = new Animation(NDalicPINVOKE.Animation_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Play the animation.
+ /// </summary>
public void Play()
{
NDalicPINVOKE.Animation_Play(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Plays the animation from a given point.
+ /// The progress must be in the 0-1 interval or in the play range interval if defined
+ /// otherwise, it will be ignored.
+ /// </summary>
+ /// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing</param>
public void PlayFrom(float progress)
{
NDalicPINVOKE.Animation_PlayFrom(swigCPtr, progress);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Pauses the animation.
+ /// </summary>
public void Pause()
{
NDalicPINVOKE.Animation_Pause(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Stops the animation.
+ /// </summary>
public void Stop()
{
NDalicPINVOKE.Animation_Stop(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Clears the animation.
+ /// This disconnects any objects that were being animated, effectively stopping the animation.
+ /// </summary>
public void Clear()
{
NDalicPINVOKE.Animation_Clear(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.
+ /// Cancel : When the animation ends, the animated property values are saved.
+ /// Discard : When the animation ends, the animated property values are forgotten.
+ /// StopFinal : If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.
+ /// </summary>
public enum EndActions
{
Cancel,
StopFinal
}
+ /// <summary>
+ /// Enumeration for what interpolation method to use on key-frame animations.
+ /// Linear : Values in between key frames are interpolated using a linear polynomial. (Default)
+ /// Cubic : Values in between key frames are interpolated using a cubic polynomial.
+ /// </summary>
public enum Interpolation
{
Linear,
Cubic
}
+ /// <summary>
+ /// Enumeration for what state the animation is in.
+ /// Note: Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.
+ /// </summary>
public enum States
{
Stopped,
-//------------------------------------------------------------------------------
-// <auto-generated />
+// Copyright (c) 2017 Samsung Electronics Co., Ltd.
//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// 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
//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
+// 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>
+ /// Button is a base class for different kinds of buttons.
+ /// This class provides the disabled property and the clicked signal.
+ /// A Clicked event handler is emitted when the button is touched and the touch point doesn't leave the boundary of the button.
+ /// When the disabled property is set to true, no signal is emitted.
+ /// 'Visual' describes not just traditional images like png, bmp but refers to whatever is used to show the button, it could be a color, gradient or some other kind of renderer.
+ /// The button's appearance can be modified by setting properties for the various visuals/images.
+ /// It is not mandatory to set all visuals. A button could be defined only by setting its background visual or by setting its background and selected visuals.
+ /// The button visual is shown over the background visual.
+ /// When pressed the unselected visuals are replaced by the selected visual.
+ /// The text label is always placed on the top of all images.
+ /// When the button is disabled, background, button and selected visuals are replaced by their disabled visuals.
+ /// </summary>
public class Button : View
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make Button instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
return ret;
}
+ /// <summary>
+ /// Gets/Sets the unselected button foreground/icon visual
+ /// </summary>
public Tizen.NUI.PropertyMap UnselectedVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the selected button foreground/icon visual
+ /// </summary>
public Tizen.NUI.PropertyMap SelectedVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the disabled selected state foreground/icon button visual
+ /// </summary>
public Tizen.NUI.PropertyMap DisabledSelectedVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the disabled unselected state foreground/icon visual
+ /// </summary>
public Tizen.NUI.PropertyMap DisabledUnselectedVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the disabled in the unselected state background, button visual
+ /// </summary>
public Tizen.NUI.PropertyMap UnselectedBackgroundVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the selected background button visual
+ /// </summary>
public Tizen.NUI.PropertyMap SelectedBackgroundVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the disabled while unselected background button visual
+ /// </summary>
public Tizen.NUI.PropertyMap DisabledUnselectedBackgroundVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the disabled while selected background button visual
+ /// </summary>
public Tizen.NUI.PropertyMap DisabledSelectedBackgroundVisual
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the position of the the label in relation to the foreground/icon if both present
+ /// </summary>
public string LabelRelativeAlignment
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the padding around the text
+ /// </summary>
public Vector4 LabelPadding
{
get
}
}
+ /// <summary>
+ /// Gets/Sets the padding around the foreground visual
+ /// </summary>
public Vector4 VisualPadding
{
get
}
+ /// <summary>
+ /// Creates an uninitialized Button.
+ /// Only derived versions can be instantiated.
+ /// </summary>
public Button() : this(NDalicPINVOKE.new_Button__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to Button handle.
+ /// If handle points to a Button, the downcast produces valid handle.
+ /// If not the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>A handle to a Button or an uninitialized handle</returns>
public new static Button DownCast(BaseHandle handle)
{
Button ret = new Button(NDalicPINVOKE.Button_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Retrieves button's animation time.
+ /// </summary>
+ /// <returns></returns>
public float GetAnimationTime()
{
float ret = NDalicPINVOKE.Button_GetAnimationTime(swigCPtr);
PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
}
+ /// <summary>
+ /// Gets/Sets the button as disabled.
+ /// </summary>
public bool Disabled
{
get
SetProperty(Button.Property.DISABLED, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// If the autorepeating property is set to true then the togglable property is set to false
+ /// </summary>
public bool AutoRepeating
{
get
SetProperty(Button.Property.AUTO_REPEATING, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// By default this value is set to 0.15 seconds.
+ /// </summary>
public float InitialAutoRepeatingDelay
{
get
SetProperty(Button.Property.INITIAL_AUTO_REPEATING_DELAY, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// default this value is set to 0.05 seconds
+ /// </summary>
public float NextAutoRepeatingDelay
{
get
SetProperty(Button.Property.NEXT_AUTO_REPEATING_DELAY, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// If the togglable property is set to true, then the autorepeating property is set to false.
+ /// </summary>
public bool Togglable
{
get
SetProperty(Button.Property.TOGGLABLE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// /Gets/Sets the togglable button as either selected or unselected, togglable property must be set to true.
+ /// </summary>
public bool Selected
{
get
SetProperty(Button.Property.SELECTED, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the unselected button foreground image
+ /// </summary>
public Tizen.NUI.PropertyMap UnselectedStateImage
{
get
SetProperty(Button.Property.UNSELECTED_STATE_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the selected button foreground image
+ /// </summary>
public Tizen.NUI.PropertyMap SelectedStateImage
{
get
SetProperty(Button.Property.SELECTED_STATE_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the disabled whilst unselected foreground button visual
+ /// </summary>
public Tizen.NUI.PropertyMap DisabledStateImage
{
get
SetProperty(Button.Property.DISABLED_STATE_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets unselected color
+ /// </summary>
public Color UnselectedColor
{
get
SetProperty(Button.Property.UNSELECTED_COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets selected color
+ /// </summary>
public Color SelectedColor
{
get
SetProperty(Button.Property.SELECTED_COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets label
+ /// </summary>
public Tizen.NUI.PropertyMap Label
{
get
SetProperty(Button.Property.LABEL, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets text of label
+ /// </summary>
public string LabelText
{
get
-/** 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 />
+// 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
//
-// This file was automatically generated by SWIG (http://www.swig.org).
-// Version 3.0.9
+// 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.
//
-// Do not make changes to this file unless you know what you are doing--modify
-// the SWIG interface file instead.
-//------------------------------------------------------------------------------
+//
+// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
+// Some have been manually changed
namespace Tizen.NUI
{
+ /// <summary>
+ /// CameraActor controls a camera.
+ /// Allows the developer to use actor semantics to control a camera.
+ /// NUI has a concept of a camera to display its virtual 3D world to a 2D screen.
+ /// There are 2 ways of using the camera in NUI:
+ /// - 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.
+ /// - For 3D applications, you can change the view by manipulating the camera.You can translate or rotate the camera in this case.
+ /// 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.
+ /// There are two types of camera actor, FreeLook and LookAtTarget By default, the camera actor will be FreeLook.
+ /// - A FreeLook camera uses actor's orientation to control where the camera is looking.
+ /// If no additional rotations are specified, the camera looks in the negative Z direction.
+ /// - For LookAtTarget, the actor's orientation is ignored, instead the camera looks at TargetPosition in world coordinates.
+ /// /// </summary>
public class CameraActor : Actor
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make CameraActor instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
+ /// <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.
+ /// Sets the default camera perspective projection for the given canvas size
+ /// </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.
+ /// If handle points to a CameraActor, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </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();
}
+ /// <summary>
+ /// Gets/Sets the camera type. The default type is FreeLook
+ /// </summary>
public string Type
{
get
SetProperty(CameraActor.Property.TYPE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the projection mode.
+ /// </summary>
public string ProjectionMode
{
get
SetProperty(CameraActor.Property.PROJECTION_MODE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets the field of view.
+ /// </summary>
public float FieldOfView
{
get
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
SetProperty(CameraActor.Property.ASPECT_RATIO, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets near plane distance
+ /// </summary>
public float NearPlaneDistance
{
get
SetProperty(CameraActor.Property.NEAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets far plane distance
+ /// </summary>
public float FarPlaneDistance
{
get
SetProperty(CameraActor.Property.FAR_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets left plane distance
+ /// </summary>
public float LeftPlaneDistance
{
get
SetProperty(CameraActor.Property.LEFT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets right plane distance
+ /// </summary>
public float RightPlaneDistance
{
get
SetProperty(CameraActor.Property.RIGHT_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets top plane distance
+ /// </summary>
public float TopPlaneDistance
{
get
SetProperty(CameraActor.Property.TOP_PLANE_DISTANCE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Gets/Sets bottom plane distance
+ /// </summary>
public float BottomPlaneDistance
{
get
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
return temp;
}
}
+
+ /// <summary>
+ /// Requests for an inversion on the Y axis on the projection calculation.
+ /// </summary>
public bool InvertYAxis
{
get
}
+ /// <summary>
+ /// Enumeration for type determination of how camera operates.
+ /// FreeLook : Camera orientation is taken from CameraActor
+ /// LookAtTarget : Camera is oriented to always look at a target
+ /// </summary>
public enum CameraType
{
FreeLook,
LookAtTarget
}
+ /// <summary>
+ /// Enumeration for projection modes.
+ /// PerspectiveProjection : Distance causes foreshortening; objects further from the camera appear smaller
+ /// OrthographicProjection : Relative distance from the camera does not affect the size of objects
+ /// </summary>
public enum ProjectionMode
{
PerspectiveProjection,
-/** 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 />
+// 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 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.
-//------------------------------------------------------------------------------
+// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
+// Some have been manually changed
namespace Tizen.NUI
{
+ /// <summary>
+ /// CheckBoxButton provides a check box button which user can check or uncheck.
+ /// By default, a CheckBoxButton emits a Button.Clicked event when the button changes its state to selected or unselected.
+ /// The button's appearance could be modified by Button.UnselectedImage, Button.BackgroundImage, Button.SelectedImage,
+ /// Button.SelectedBackgroundImage, Button.DisabledBackgroundImage, Button.DisabledImage, and Button.DisabledSelectedImage.
+ /// When the button is not disabled, if it's not selected it only shows the background image.
+ /// The selected image is shown over the background image when the box is selected (background image is not replaced by \e selected image).
+ /// When the button is disabled, background image and selected image are replaced by disabled images.
+ /// /// </summary>
public class CheckBoxButton : Button
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+
+ /// <summary>
+ /// To make CheckBoxButton instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
}
-
+ /// <summary>
+ /// Creates an initialized CheckBoxButton
+ /// </summary>
public CheckBoxButton() : this(NDalicPINVOKE.CheckBoxButton_New(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-/*\r
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.\r
- *\r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- *\r
- */\r
+// 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
\r
using System;\r
using System.Runtime.InteropServices;\r
\r
namespace Tizen.NUI\r
{\r
+ ///<summary>\r
+ ///Spin CustomView class\r
+ /// </summary>\r
public class Spin : CustomView\r
{\r
private VisualBase _arrowVisual;\r
\r
}\r
\r
+ /// <summary>\r
+ /// Override method of OnInitialize() for CustomView class.\r
+ /// This method is called after the Control has been initialized.\r
+ /// Derived classes should do any second phase initialization by overriding this method.\r
+ /// </summary>\r
public override void OnInitialize()\r
{\r
// Initialize the propertiesControl\r
_textField.FocusLost += TextFieldKeyInputFocusLost;\r
}\r
\r
+ /// <summary>\r
+ /// Override method of GetNaturalSize() for CustomView class.\r
+ /// Return the natural size of the actor.\r
+ /// </summary>\r
+ /// <returns> Natural size of this Spin itself</returns>\r
public override Size GetNaturalSize()\r
{\r
return new Size(150.0f, 150.0f, 0.0f);\r
}\r
\r
+ /// <summary>\r
+ /// Event handler when the TextField in Spin gets the Key focus\r
+ /// Make sure when the current spin that takes input focus also takes the keyboard focus\r
+ /// For example, when you tap the spin directly\r
+ /// </summary>\r
+ /// <param name="source">Sender of this event</param>\r
+ /// <param name="e">Event arguments</param>\r
public void TextFieldKeyInputFocusGained(object source, EventArgs e)\r
{\r
- // Make sure when the current spin that takes input focus also takes the keyboard focus\r
- // For example, when you tap the spin directly\r
FocusManager.Instance.SetCurrentFocusView(_textField);\r
}\r
\r
+ /// <summary>\r
+ /// Event handler when the TextField in Spin looses it's Key focus\r
+ /// </summary>\r
+ /// <param name="source"></param>\r
+ /// <param name="e"></param>\r
public void TextFieldKeyInputFocusLost(object source, EventArgs e)\r
{\r
int previousValue = _currentValue;\r
this.Value = _currentValue;\r
}\r
\r
+ /// <summary>\r
+ /// Override method of GetNextKeyboardFocusableActor() for CustomView class.\r
+ /// Gets the next key focusable actor in this View towards the given direction.\r
+ /// A View needs to override this function in order to support two dimensional key navigation.\r
+ /// </summary>\r
+ /// <param name="currentFocusedActor">The current focused actor</param>\r
+ /// <param name="direction">The direction to move the focus towards</param>\r
+ /// <param name="loopEnabled">Whether the focus movement should be looped within the control</param>\r
+ /// <returns>The next keyboard focusable actor in this control or an empty handle if no actor can be focused</returns>\r
public override Actor GetNextKeyboardFocusableActor(Actor currentFocusedActor, View.FocusDirection direction, bool loopEnabled)\r
{\r
// Respond to Up/Down keys to change the value while keeping the current spin focused\r
return nextFocusedActor;\r
}\r
\r
-\r
+ /// <summary>\r
+ /// Value to be set in Spin\r
+ /// </summary>\r
[ScriptableProperty()]\r
public int Value\r
{\r
_textField.Text = _currentValue.ToString();\r
}\r
}\r
+ \r
+ /// <summary>\r
+ /// Minimum Value of Spin Value\r
+ /// </summary>\r
// MinValue property of type int:\r
[ScriptableProperty()]\r
public int MinValue\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Maximum Value of Spin Value\r
+ /// </summary>\r
// MaxValue property of type int:\r
[ScriptableProperty()]\r
public int MaxValue\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Increasing, decresing step of Spin Value when Up or Down key is pressed\r
+ /// </summary>\r
// Step property of type int:\r
[ScriptableProperty()]\r
public int Step\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Wrapping enabled status\r
+ /// </summary>\r
// WrappingEnabled property of type bool:\r
[ScriptableProperty()]\r
public bool WrappingEnabled\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Text point size of Spin Value\r
+ /// </summary>\r
// TextPointSize property of type int:\r
[ScriptableProperty()]\r
public int TextPointSize\r
}\r
}\r
\r
+ /// <summary>\r
+ /// The color of Spin Value\r
+ /// </summary>\r
// TextColor property of type Color:\r
[ScriptableProperty()]\r
public Color TextColor\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Maximum text lengh of Spin Value\r
+ /// </summary>\r
// MaxTextLength property of type int:\r
[ScriptableProperty()]\r
public int MaxTextLength\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Reference of TextField of Spin\r
+ /// </summary>\r
public TextField SpinText\r
{\r
get\r
}\r
}\r
\r
+ /// <summary>\r
+ /// Show indicator image, for example Up/Down Arrow image.\r
+ /// </summary>\r
// Indicator property of type string:\r
public string IndicatorImage\r
{\r
_visualDictionary.Clear();\r
}\r
\r
+ /// <summary>\r
+ /// Override method of OnRelayout() for CustomView class.\r
+ /// Called after the size negotiation has been finished for this control.\r
+ /// The control is expected to assign this given size to itself/its children.\r
+ /// 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.\r
+ /// Note! As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored)\r
+ /// </summary>\r
+ /// <param name="size">The allocated size</param>\r
+ /// <param name="container">The control should add actors to this container that it is not able to allocate a size for.</param>\r
public override void OnRelayout(Vector2 size, RelayoutContainer container)\r
{\r
foreach (var item in _visualDictionary)\r
namespace Tizen.NUI
{
+ /// <summary>
+ /// A 3D parametric curve.
+ /// Paths can be used to animate position and orientation of actors.
+ /// </summary>
public class Path : Handle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
+ /// <summary>
+ /// Creates an initialized Path handle.
+ /// </summary>
public Path() : this(NDalicPINVOKE.Path_New(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Downcasts a handle to Path handle.
+ /// If handle points to a Path object, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
public new static Path DownCast(BaseHandle handle)
{
Path ret = new Path(NDalicPINVOKE.Path_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Adds an interpolation point.
+ /// </summary>
+ /// <param name="point">The new interpolation point to be added</param>
public void AddPoint(Position point)
{
NDalicPINVOKE.Path_AddPoint(swigCPtr, Position.getCPtr(point));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Adds a control point.
+ /// </summary>
+ /// <param name="point">The new control point to be added</param>
public void AddControlPoint(Vector3 point)
{
NDalicPINVOKE.Path_AddControlPoint(swigCPtr, Vector3.getCPtr(point));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Automatic generation of control points. Generated control points which result in a smooth join between the splines of each segment.
+ /// The generating algorithm is as follows:
+ /// For a given knot point K[N], find the vector that bisects K[N-1],[N] and [N],[N+1].
+ /// Calculate the tangent vector by taking the normal of this bisector.
+ /// The in control point is the length of the preceding segment back along this bisector multiplied by the curvature.
+ /// The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature.
+ /// </summary>
+ /// <param name="curvature">The curvature of the spline. 0 gives straight lines between the knots, negative values means the spline contains loops, positive values up to 0.5 result in a smooth curve, positive values between 0.5 and 1 result in looped curves where the loops are not distinct (i.e. the curve appears to be non-continuous), positive values higher than 1 result in looped curves</param>
public void GenerateControlPoints(float curvature)
{
NDalicPINVOKE.Path_GenerateControlPoints(swigCPtr, curvature);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Sample path at a given progress. Calculates position and tangent at that point of the curve.
+ /// </summary>
+ /// <param name="progress">A floating point value between 0.0 and 1.0</param>
+ /// <param name="position">The interpolated position at that progress</param>
+ /// <param name="tangent">The interpolated tangent at that progress</param>
public void Sample(float progress, Vector3 position, Vector3 tangent)
{
NDalicPINVOKE.Path_Sample(swigCPtr, progress, Vector3.getCPtr(position), Vector3.getCPtr(tangent));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Accessor for the interpolation points.
+ /// </summary>
+ /// <param name="index">The index of the interpolation point</param>
public Vector3 GetPoint(uint index)
{
Vector3 ret = new Vector3(NDalicPINVOKE.Path_GetPoint(swigCPtr, index), false);
return ret;
}
+ /// <summary>
+ /// Accessor for the control points.
+ /// </summary>
+ /// <param name="index">The index of the control point</param>
public Vector3 GetControlPoint(uint index)
{
Vector3 ret = new Vector3(NDalicPINVOKE.Path_GetControlPoint(swigCPtr, index), false);
return ret;
}
+ /// <summary>
+ /// Gets the number of interpolation points in the path.
+ /// </summary>
+ /// <returns>The number of interpolation points in the path</returns>
public uint GetPointCount()
{
uint ret = NDalicPINVOKE.Path_GetPointCount(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Enumeration for Points
+ /// </summary>
public PropertyArray Points
{
get
}
}
+ /// <summary>
+ /// Enumeration for ControlPoints
+ /// </summary>
public PropertyArray ControlPoints
{
get
namespace Tizen.NUI
{
+ /// <summary>
+ /// A PinchGesture is emitted when the user moves two fingers towards or away from each other.
+ /// A pinch gesture will continue to be sent to the actor under the center point of the pinch until the pinch ends.
+ /// </summary>
public class PinchGesture : Gesture
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
return ret;
}
+ /// <summary>
+ /// The scale factor from the start of the pinch gesture till the latest pinch gesture.
+ /// If the user is moving their fingers away from each other, then
+ /// this value increases. Conversely, if the user is moving their
+ /// fingers towards each other, this value will decrease.
+ /// </summary>
public float Scale
{
get
}
}
+ /// <summary>
+ /// The speed at which the user is moving their fingers.
+ /// This is the pixel movement per second.
+ /// </summary>
public float Speed
{
get
}
}
+ /// <summary>
+ /// The center point of the two points that caused the pinch gesture in screen coordinates.
+ /// </summary>
public Vector2 ScreenCenterPoint
{
get
}
}
+ /// <summary>
+ /// The center point of the two points that caused the pinch gesture in local actor coordinates.
+ /// </summary>
public Vector2 LocalCenterPoint
{
get
}
}
+ /// <summary>
+ /// Default Constructor.
+ /// </summary>
+ /// <param name="state">The state of the gesture</param>
public PinchGesture(Gesture.StateType state) : this(NDalicPINVOKE.new_PinchGesture__SWIG_0((int)state), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Copy constructor.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
public PinchGesture(PinchGesture rhs) : this(NDalicPINVOKE.new_PinchGesture__SWIG_1(PinchGesture.getCPtr(rhs)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Assignment operator.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
public PinchGesture Assign(PinchGesture rhs)
{
PinchGesture ret = new PinchGesture(NDalicPINVOKE.PinchGesture_Assign(swigCPtr, PinchGesture.getCPtr(rhs)), false);
projects / platform / core / csapi / nui.git / commitdiff