<Compile Include="src\public\Radian.cs" />\r
<Compile Include="src\public\RadioButton.cs" />\r
<Compile Include="src\public\Rectangle.cs" />\r
+ <Compile Include="src\public\RelativeVector2.cs" />\r
+ <Compile Include="src\public\RelativeVector3.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\ScrollBar.cs" />\r
internal void SetupDelegates()
{
InitDelegateInternal initializeCallback = new InitDelegateInternal(Initialize);
- System.Console.WriteLine("InitSignal connection count");
+ Tizen.Log.Debug("NUI", "InitSignal connection count");
this.InitSignal().Connect(initializeCallback);
- //Console.WriteLine( "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
+ //Tizen.Log.Debug("NUI", "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
}
public static Application NewApplication()
startEventPropertyIndex += (int)Tizen.NUI.PropertyRanges.DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION; // DALi uses 10,000
startAnimatablePropertyIndex += maxCountPerDerivation;
- //Console.WriteLine ("getStartPropertyIndex = " + viewType.Name +"current index " + startEventPropertyIndex);
+ //Tizen.Log.Debug("NUI", "getStartPropertyIndex = " + viewType.Name +"current index " + startEventPropertyIndex);
#if (DOT_NET_CORE)
viewType = viewType.GetTypeInfo().BaseType;
#else
Tizen.NUI.PropertyType daliType;
if (_daliPropertyTypeLookup.TryGetValue(cSharpTypeName, out daliType))
{
- //Console.WriteLine("mapped "+ cSharpTypeName + " to dAli type " +daliType );
+ //Tizen.Log.Debug("NUI", "mapped "+ cSharpTypeName + " to dAli type " +daliType );
return daliType;
}
else
{
- // Console.WriteLine("Failed to find a mapping between C# property" + cSharpTypeName +" and DALi type");
+ // Tizen.Log.Debug("NUI", "Failed to find a mapping between C# property" + cSharpTypeName +" and DALi type");
return PropertyType.None;
}
}
private static IntPtr CreateControl(IntPtr cPtrControlName)
{
string controlName = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(cPtrControlName);
- // Console.WriteLine ("Create controlled called from C++ create a " + controlName);
+ // Tizen.Log.Debug("NUI", "Create controlled called from C++ create a " + controlName);
Func<CustomView> controlConstructor;
RefObject refObj = view.GetObjectPtr();
IntPtr refCptr = (IntPtr)RefObject.getCPtr(refObj);
- //Console.WriteLine ("________Storing ref object cptr in control map Hex: {0:X}", refCptr);
+ //Tizen.Log.Debug("NUI", "________Storing ref object cptr in control map Hex: {0:X}", refCptr);
if (!Instance._controlMap.ContainsKey(refCptr))
{
Instance._controlMap.Add(refCptr, new WeakReference(view, false));
private static void SetProperty(IntPtr controlPtr, IntPtr propertyName, IntPtr propertyValue)
{
string name = System.Runtime.InteropServices.Marshal.PtrToStringAnsi(propertyName);
- //Console.WriteLine ( SetControlProperty called for:" + name );
+ //Tizen.Log.Debug("NUI", SetControlProperty called for:" + name );
Instance.SetPropertyValue(controlPtr, name, propertyValue);
}
// If the Scriptable attribute exists, then register it with the type registry.
if (attr is ScriptableProperty)
{
- //Console.WriteLine ("Got a DALi JSON scriptable property = " + propertyInfo.Name +", of type " + propertyInfo.PropertyType.Name);
+ //Tizen.Log.Debug("NUI", "Got a DALi JSON scriptable property = " + propertyInfo.Name +", of type " + propertyInfo.PropertyType.Name);
// first get the attribute type, ( default, or animatable)
ScriptableProperty scriptableProp = attr as ScriptableProperty;
TypeRegistration.RegisterProperty(viewType.Name, propertyInfo.Name, propertyIndex, propertyType, _setPropertyCallback, _getPropertyCallback);
}
}
- // Console.WriteLine ("property name = " + propertyInfo.Name);
+ // Tizen.Log.Debug("NUI", "property name = " + propertyInfo.Name);
}
}
}
{
// Get the C# control that maps to the C++ control
- //Console.WriteLine ("SetPropertyValue refObjectPtr = {0:X}", controlPtr);
+ //Tizen.Log.Debug("NUI", "SetPropertyValue refObjectPtr = {0:X}", controlPtr);
PropertyValue propValue = new PropertyValue(propertyValuePtr, false);
}
/// <summary>
- /// Retrieve the position of the Actor.<br>
+ /// Retrieves the position of the Actor.<br>
/// The coordinates are relative to the Actor's parent.<br>
/// </summary>
public Position CurrentPosition
}
/// <summary>
- /// Retrieve the size of the Actor.<br>
+ /// Retrieves the size of the Actor.<br>
/// The coordinates are relative to the Actor's parent.<br>
/// </summary>
public Size CurrentSize
}
/// <summary>
- /// Determines whether the anchor point should be used to determine the position of the actor.<br>
- /// This is true by default.<br>
- /// Note: If false, then the top-left of the actor is used for the position.<br>
- /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the actor's position.<br>
+ /// 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>
protected bool PositionUsesAnchorPoint
{
get
}
/// <summary>
- /// Sets the sibling order of the actor so depth position can be defined within the same parent.<br>
- /// Note The initial value is 0.<br>
- /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.<br>
- /// The values set by this Property will likely change.<br>
+ /// 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
}
/// <summary>
- /// Sets the size of an actor for Width and Height.<br>
+ /// 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>
+ /// The actors default depth is the minimum of width & height.<br>
/// </summary>
public Size2D Size2D
{
}
/// <summary>
- /// Sets the visibility flag of an actor as true to be shown.<br>
- /// Note This is an asynchronous method; the value written may not match a value subsequently read with Visible.<br>
- /// If an actor's visibility flag is set to false, then the actor and its children will not be rendered.<br>
- /// 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.<br>
+ /// Shows the Actor.
/// </summary>
+ /// <remarks>
+ /// This is an asynchronous method.
+ /// </remarks>
public void Show()
{
SetVisible(true);
}
/// <summary>
- /// Sets the visibility flag of an actor as false to be hidden.
+ /// 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).<br>
- /// Note Sibling order of actors within the parent will be updated automatically.<br>
- /// Initially actors added to a parent will have the same sibling order and shown in relation to insertion order.<br>
- /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.<br>
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
+ /// 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);
}
/// <summary>
- /// Lower the actor to underneath the level below actor(s).<br>
- /// Note Sibling order of actors within the parent will be updated automatically.<br>
- /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.<br>
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
+ /// 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);
}
/// <summary>
- /// Raise actor above all other actors.<br>
- /// Note Sibling order of actors within the parent will be updated automatically.<br>
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
+ /// 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);
}
/// <summary>
- /// Lower actor to the bottom of all actors.<br>
- /// Note Sibling order of actors within the parent will be updated automatically.<br>
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
+ /// 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);
}
/// <summary>
- /// Raise the actor to above the target actor.<br>
- /// Note Sibling order of actors within the parent will be updated automatically.<br>
- /// Actors on the level above the target actor will still be shown above this actor.<br>
- /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.<br>
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
+ /// 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)
{
}
/// <summary>
- /// Lower the actor to below the target actor.<br>
- /// Note Sibling order of actors within the parent will be updated automatically.<br>
- /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.<br>
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
+ /// 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)
{
/// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">handle to An object</param>
- /// <returns>handle to a Actor object or an uninitialized handle</returns>
+ /// <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);
}
/// <summary>
- /// Adds a child Actor to this Actor.<br>
- /// 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.<br>
- /// 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.<br>
- /// 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.<br>
+ /// 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)
{
}
/// <summary>
- /// Removes a child Actor from this Actor. If the actor was not a child of this actor, this is a no-op.<br>
- /// Precondition : This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.<br>
+ /// 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)
{
}
/// <summary>
- /// Retrieves the number of children held by the actor.<br>
- /// Precondition : The Actor has been initialized.<br>
+ /// 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()
{
}
/// <summary>
- /// Retrieve and child actor by index.<br>
- /// Precondition : The Actor has been initialized.<br>
+ /// 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)
}
/// <summary>
- /// Search through this actor's hierarchy for an actor with the given name.<br>
- /// The actor itself is also considered in the search.<br>
- ///Precondition : The Actor has been initialized.<br>
+ /// 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)
}
/// <summary>
- /// Converts screen coordinates into the actor's coordinate system using the default camera.<br>
- /// Precondition : The Actor has been initialized.<br>
- /// Note : The actor coordinates are relative to the top-left(0.0, 0.0, 0.5).<br>
+ /// 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>
/// <summary>
/// Sets the relative to parent size factor of the actor.<br>
- /// This factor is only used when ResizePolicy is set to either.<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>
- /// Precondition : The Actor has been initialized.<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)
{
/// 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>
+ /// <returns>The height based on the width</returns>
public float GetHeightForWidth(float width)
{
float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
/// 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>
+ /// <returns>The width based on the height</returns>
public float GetWidthForHeight(float height)
{
float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
/// <summary>
/// Sets the padding for use in layout.<br>
/// </summary>
- /// <param name="padding">padding Padding for the actor</param>
+ /// <param name="padding">Padding for the actor</param>
public void SetPadding(PaddingType padding)
{
NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
/// <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>
+ /// 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>
- /// Precondition : The Actor has been initialized.<br>
/// </summary>
+ /// <pre>The Actor has been initialized.</pre>
public Position ParentOrigin
{
get
/// <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>
+ /// 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>
- /// Precondition : The Actor has been initialized.
+ /// <pre>The Actor has been initialized.</pre>
/// </summary>
public Position AnchorPoint
{
/// <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>
- /// Note: This is an asynchronous method.<br>
/// </summary>
+ /// <remarks>This is an asynchronous method.</remarks>
public Rotation Orientation
{
get
/// <summary>
/// Gets/Sets the scale factor applied to an actor.<br>
- /// Note : This is an asynchronous method.<br>
/// </summary>
public Vector3 Scale
{
}
/// <summary>
- /// Retrieves the visibility flag of an actor.<br>
- /// Note : If an actor is not visible, then the actor and its children will not be rendered.<br>
- /// 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.<br>
+ /// 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
}
/// <summary>
- /// Gets/Sets the width resize policy to be used for the given dimension(s).
+ /// Gets/Sets the width resize policy to be used.
/// </summary>
public ResizePolicyType WidthResizePolicy
{
}
/// <summary>
- /// Gets/Sets the height resize policy to be used for the given dimension(s).
+ /// Gets/Sets the height resize policy to be used.
/// </summary>
public ResizePolicyType HeightResizePolicy
{
}
/// <summary>
- /// This specifies whether the Actor uses its own color, or inherits.<br>
- /// ColorMode.UseOwnColor : Actor will use its own color.<br>
- /// ColorMode.UseParentColor : Actor will use its parent color.<br>
- /// ColorMode.UseOwnMultiplyParentColor : Actor will blend its color with its parents color.<br>
- /// 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.<br>
+ /// This specifies whether the Actor uses its own color, or inherits.
/// </summary>
public enum ColorMode
{
+ /// <summary>
+ /// Actor will use its own color.
+ /// </summary>
UseOwnColor,
+ /// <summary>
+ /// Actor will use its parent color.
+ /// </summary>
UseParentColor,
+ /// <summary>
+ /// Actor will blend its color with its parents color.
+ /// </summary>
UseOwnMultiplyParentColor,
+ /// <summary>
+ /// 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>
UseOwnMultiplyParentAlpha
}
/// </summary>
public enum DimensionType
{
+ /// <summary>
+ /// Width dimension
+ /// </summary>
Width = 0x1,
+ /// <summary>
+ /// Height dimension
+ /// </summary>
Height = 0x2,
+ /// <summary>
+ /// Mask to cover all flags
+ /// </summary>
AllDimensions = 0x3
}
/// <summary>
- /// This specifies draw mode types
+ /// Enumeration for the instance of how the actor and it's children will be drawn.
/// </summary>
public enum DrawModeType
{
+ /// <summary>
+ /// The default draw-mode
+ /// </summary>
Normal = 0,
+ /// <summary>
+ /// Draw the actor and its children as an overlay
+ /// </summary>
Overlay2D = 1,
+ /// <summary>
+ /// Will be replaced by separate ClippingMode enum. Draw the actor and its children into the stencil buffer
+ /// </summary>
Stencil = 3
}
/// <summary>
- /// This specifies resize policy types
+ /// Enumeration for size negotiation resize policies.
/// </summary>
public enum ResizePolicyType
{
+ /// <summary>
+ /// Size is fixed as set by SetSize
+ /// </summary>
Fixed,
+ /// <summary>
+ /// Size is to use the actor's natural size
+ /// </summary>
+ /// <see cref="Actor.GetNaturalSize"/>
UseNaturalSize,
+ /// <summary>
+ /// Size is to fill up to the actor's parent's bounds. Aspect ratio is not maintained.
+ /// </summary>
FillToParent,
+ /// <summary>
+ /// The actors size will be ( ParentSize * SizeRelativeToParentFactor ).
+ /// </summary>
SizeRelativeToParent,
+ /// <summary>
+ /// The actors size will be ( ParentSize + SizeRelativeToParentFactor ).
+ /// </summary>
SizeFixedOffsetFromParent,
+ /// <summary>
+ /// Size will adjust to wrap around all children
+ /// </summary>
FitToChildren,
+ /// <summary>
+ /// One dimension is dependent on the other
+ /// </summary>
DimensionDependency,
+ /// <summary>
+ /// The size will be assigned to the actor
+ /// </summary>
UseAssignedSize
}
/// <summary>
- /// This specifies size scale policy types
+ /// Enumeration for policies to determine how an actor should resize itself when having its size set in size negotiation.
/// </summary>
public enum SizeScalePolicyType
{
+ /// <summary>
+ /// Use the size that was set
+ /// </summary>
UseSizeSet,
+ /// <summary>
+ /// Fit within the size set maintaining natural size aspect ratio
+ /// </summary>
FitWithAspectRatio,
+ /// <summary>
+ /// Fit within the size set maintaining natural size aspect ratio
+ /// </summary>
FillWithAspectRatio
}
/// <summary>
- /// This specifies clipping mode types
+ /// Enumeration for ClippingMode describing how this Actor's children will be clipped against it.
/// </summary>
public enum ClippingModeType
{
+ /// <summary>
+ /// This Actor will not clip its children.
+ /// </summary>
Disabled,
+ /// <summary>
+ /// This Actor will clip all children to within its boundaries (the actor will also be visible itself).
+ /// </summary>
ClipChildren
}
/// <summary>
/// Constructor.<br>
/// Creates a bezier alpha function.The bezier will have the first point at(0,0) and the end point at(1,1).<br>
- /// Note : The x components of the control points will be clamped to the range[0, 1] to prevent non monotonic curves.<br>
/// </summary>
+ /// <remarks>The x components of the control points will be clamped to the range[0, 1] to prevent non monotonic curves.</remarks>
/// <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)
/// </summary>
public enum BuiltinFunctions
{
+ /// <summary>
+ /// Linear
+ /// </summary>
Default,
+ /// <summary>
+ /// No transformation
+ /// </summary>
Linear,
+ /// <summary>
+ /// Reverse linear
+ /// </summary>
Reverse,
+ /// <summary>
+ /// Speeds up and comes to a sudden stop (Square)
+ /// </summary>
EaseInSquare,
+ /// <summary>
+ /// Sudden start and slows to a gradual stop (Square)
+ /// </summary>
EaseOutSquare,
+ /// <summary>
+ /// Speeds up and comes to a sudden stop (Cubic)
+ /// </summary>
EaseIn,
+ /// <summary>
+ /// Sudden start and slows to a gradual stop (Cubic)
+ /// </summary>
EaseOut,
+ /// <summary>
+ /// Speeds up and slows to a gradual stop (Cubic)
+ /// </summary>
EaseInOut,
+ /// <summary>
+ /// Speeds up and comes to a sudden stop (sinusoidal)
+ /// </summary>
EaseInSine,
+ /// <summary>
+ /// Sudden start and slows to a gradual stop (sinusoidal)
+ /// </summary>
EaseOutSine,
+ /// <summary>
+ /// Speeds up and slows to a gradual stop (sinusoidal)
+ /// </summary>
EaseInOutSine,
+ /// <summary>
+ /// Sudden start, loses momentum and returns to start position
+ /// </summary>
Bounce,
+ /// <summary>
+ /// Single revolution
+ /// </summary>
Sin,
+ /// <summary>
+ /// Sudden start, exceed end position and return to a gradual stop
+ /// </summary>
EaseOutBack,
Count
}
/// </summary>
public enum Modes
{
+ /// <summary>
+ /// The user has provided a custom function
+ /// </summary>
CustomFunction = 1,
+ /// <summary>
+ /// The user has provided the control points of a bezier curve
+ /// </summary>
Bezier
}
/// Animation can be used to animate the properties of any number of objects, typically Actors.<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 Duration property used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.<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>
/// If any of the individual calls to those functions exceeds the overall animation time(Duration), then the overall animation time is automatically extended.<br>
/// </summary>
public class Animation : BaseHandle
/// The animation will not loop.<br>
/// The default end action is "Cancel".<br>
/// The default Alpha function is linear.<br>
- /// Precodition : DurationmSeconds must be greater than zero.<br>
/// </summary>
- /// <param name="durationMilliSeconds">The duration in milli seconds (int).</param>
+ /// <remarks>DurationmSeconds must be greater than zero.</remarks>
+ /// <param name="durationMilliSeconds">The duration in milli seconds.</param>
public Animation(int durationMilliSeconds) : this(NDalicPINVOKE.Animation_New((float)durationMilliSeconds / 1000.0f), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
/// <summary>
- /// Gets/Sets the duration of animation.
+ /// Gets/Sets the duration in milli seconds of the animation.
/// </summary>
public int Duration
{
}
/// <summary>
- /// Gets/Sets the default alpha function for an animation.
+ /// Gets/Sets the default alpha function for the animation.
/// </summary>
public AlphaFunction DefaultAlphaFunction
{
/// <summary>
/// Gets the current loop count.<br>
- /// A value 0 to CurrentLoop indicating the current loop count when looping.<br>
+ /// A value 0 indicating the current loop count when looping.<br>
/// </summary>
public int CurrentLoop
{
/// <summary>
/// Animates a property value by a relative amount.<br>
- /// The default alpha function will be used.<br>
- /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
throw new System.Exception("second argument string property is invalid parameter!");
}
- //dynamic obj = (object)relativeValue;
PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
if (alphaFunction != null)
{
- AnimateBy(_prop, new PropertyValue(val), alphaFunction);
+ AnimateBy(_prop, val, alphaFunction);
}
else
{
- AnimateBy(_prop, new PropertyValue(val));
+ AnimateBy(_prop, val);
}
}
/// <summary>
/// Animates a property value by a relative amount.<br>
- /// The default alpha function will be used.<br>
- /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
throw new System.Exception("second argument string property is invalid parameter!");
}
- //dynamic obj = (object)relativeValue;
PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
if (alphaFunction != null)
{
Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
- AnimateBy(_prop, new PropertyValue(val), alphaFunction, time);
+ AnimateBy(_prop, val, alphaFunction, time);
}
else
{
Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
- AnimateBy(_prop, new PropertyValue(val), time);
+ AnimateBy(_prop, val, time);
}
}
/// <summary>
/// Animates a property to a destination value.<br>
- /// The default alpha function will be used.<br>
- /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
throw new System.Exception("second argument string property is invalid parameter!");
}
- //dynamic obj = (object)destinationValue;
PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
if (alphaFunction != null)
{
- AnimateTo(_prop, new PropertyValue(val), alphaFunction);
+ AnimateTo(_prop, val, alphaFunction);
}
else
{
- AnimateTo(_prop, new PropertyValue(val));
+ AnimateTo(_prop, val);
}
}
/// <summary>
/// Animates a property to a destination value.<br>
- /// The default alpha function will be used.<br>
- /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</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>
+ /// <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)
{
string _str1 = property.Substring(0, 1);
throw new System.Exception("second argument string property is invalid parameter!");
}
- //dynamic obj = (object)destinationValue;
PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
if (alphaFunction != null)
{
Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
- AnimateTo(_prop, new PropertyValue(val), alphaFunction, time);
+ AnimateTo(_prop, val, alphaFunction, time);
}
else
{
Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
- AnimateTo(_prop, new PropertyValue(val), time);
+ AnimateTo(_prop, val, time);
}
}
/// <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="startTime">Start time of animation in milli seconds</param>
+ /// <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)
}
/// <summary>
- /// Play the animation.
+ /// Plays the animation.
/// </summary>
public void Play()
{
}
/// <summary>
- /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.<br>
- /// Cancel : When the animation ends, the animated property values are saved.<br>
- /// Discard : When the animation ends, the animated property values are forgotten.<br>
- /// StopFinal : If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.<br>
+ /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.
/// </summary>
public enum EndActions
{
+ /// <summary>
+ /// When the animation ends, the animated property values are saved.
+ /// </summary>
Cancel,
+ /// <summary>
+ /// When the animation ends, the animated property values are forgotten.
+ /// </summary>
Discard,
+ /// <summary>
+ /// If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.
+ /// </summary>
StopFinal
}
/// <summary>
- /// Enumeration for what interpolation method to use on key-frame animations.<br>
- /// Linear : Values in between key frames are interpolated using a linear polynomial. (Default).<br>
- /// Cubic : Values in between key frames are interpolated using a cubic polynomial.<br>
+ /// Enumeration for what interpolation method to use on key-frame animations.
/// </summary>
public enum Interpolation
{
+ /// <summary>
+ /// Values in between key frames are interpolated using a linear polynomial. (Default)
+ /// </summary>
Linear,
+ /// <summary>
+ /// Values in between key frames are interpolated using a cubic polynomial.
+ /// </summary>
Cubic
}
/// <summary>
- /// Enumeration for what state the animation is in.<br>
- /// Note: Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.<br>
+ /// Enumeration for what state the animation is in.
/// </summary>
+ /// <remarks>Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.</remarks>
public enum States
{
+ /// <summary>
+ /// Animation has stopped
+ /// </summary>
Stopped,
+ /// <summary>
+ /// The animation is playing
+ /// </summary>
Playing,
+ /// <summary>
+ /// The animation is paused
+ /// </summary>
Paused
}
/// (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>
+ /// 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>
- /// Enumeration for type determination of how camera operates.<br>
- /// FreeLook : Camera orientation is taken from CameraActor.<br>
- /// LookAtTarget : Camera is oriented to always look at a target.<br>
+ /// Enumeration for type determination of how camera operates.
/// </summary>
public enum CameraType
{
+ /// <summary>
+ /// Camera orientation is taken from CameraActor.
+ /// </summary>
FreeLook,
+ /// <summary>
+ /// Camera is oriented to always look at a target.
+ /// </summary>
LookAtTarget
}
/// <summary>
- /// Enumeration for projection modes.<br>
- /// PerspectiveProjection : Distance causes foreshortening; objects further from the camera appear smaller.<br>
- /// OrthographicProjection : Relative distance from the camera does not affect the size of objects.<br>
+ /// Enumeration for projection modes.
/// </summary>
public enum ProjectionMode
{
+ /// <summary>
+ /// Distance causes foreshortening; objects further from the camera appear smaller.
+ /// </summary>
PerspectiveProjection,
+ /// <summary>
+ /// Relative distance from the camera does not affect the size of objects.
+ /// </summary>
OrthographicProjection
}
/// <summary>
/// CheckBoxButton provides a check box button which user can check or uncheck.<br>
/// By default, a CheckBoxButton emits a Button.Clicked event when the button changes its state to selected or unselected.<br>
- /// The button's appearance could be modified by Button.UnselectedImage, Button.BackgroundImage, Button.SelectedImage,
- /// Button.SelectedBackgroundImage, Button.DisabledBackgroundImage, Button.DisabledImage, and Button.DisabledSelectedImage.<br>
+ /// The button's appearance could be modified by Button.UnselectedImage, Button.BackgroundImage, Button.SelectedImage, Button.SelectedBackgroundImage, Button.DisabledBackgroundImage, Button.DisabledImage, and Button.DisabledSelectedImage.<br>
/// When the button is not disabled, if it's not selected it only shows the background image.<br>
/// The selected image is shown over the background image when the box is selected (background image is not replaced by \e selected image).<br>
/// When the button is disabled, background image and selected image are replaced by disabled images.<br>
* limitations under the License.
*
*/
+using System.ComponentModel;
namespace Tizen.NUI
{
/// </summary>
/// <param name="child">The child actor 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</returns>
+ /// <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)
{
return viewWrapperImpl.CalculateChildSizeBase(child, dimension);
/// </summary>
public enum CustomViewBehaviour
{
+ /// <summary>
+ /// Use to provide default behaviour (size negotiation is on, event callbacks are not called)
+ /// </summary>
ViewBehaviourDefault = 0,
+ /// <summary>
+ /// True if control does not need size negotiation, i.e. it can be skipped in the algorithm
+ /// </summary>
DisableSizeNegotiation = 1 << 0,
+ /// <summary>
+ /// Use to provide key navigation support.
+ /// </summary>
RequiresKeyboardNavigationSupport = 1 << 5,
+ /// <summary>
+ /// Use to make style change event disabled.
+ /// </summary>
DisableStyleChangeSignals = 1 << 6,
+ [EditorBrowsable(EditorBrowsableState.Never)]
LastViewBehaviourFlag
}
}
set
{
- Console.WriteLine("Value set to " + value);
+ Tizen.Log.Debug("NUI", "Value set to " + value);
_currentValue = value;
// Make sure no invalid value is accepted
}
set
{
- Console.WriteLine("TextColor set to " + value.R + "," + value.G + "," + value.B);
+ Tizen.Log.Debug("NUI", "TextColor set to " + value.R + "," + value.G + "," + value.B);
_textColor = value;
_textField.TextColor = _textColor;
}
}
}
-}
\ No newline at end of file
+}
using System.Linq;
/// <summary>
- /// A visual view control for user add any visual to it.<br>
- /// Example:<br>
- /// VisualView _visualView = new VisualView();<br>
- /// ImageVisualMap imageVisualMap1 = new ImageVisualMap();<br>
- /// imageVisualMap1.URL = "./NUISample/res/images/image-1.jpg";<br>
- /// imageVisualMap1.VisualSize = new Vector2( 300.0f, 300.0f );<br>
- /// imageVisualMap1.Offset = new Vector2( 50.0f, 50.0f );<br>
- /// imageVisualMap1.OffsetSizeMode = new Vector4( 1.0f, 1.0f, 1.0f, 1.0f );<br>
- /// imageVisualMap1.Origin = AlignType.TOP_BEGIN;<br>
- /// imageVisualMap1.AnchorPoint = AlignType.TOP_BEGIN;<br>
- /// _visualView.AddVisual("imageVisual1", imageVisualMap1);<br>
+ /// A visual view control for user add any visual to it.
/// </summary>
+ /// <example>
+ /// Example:
+ /// <code>
+ /// VisualView _visualView = new VisualView();
+ /// ImageVisualMap imageVisualMap1 = new ImageVisualMap();
+ /// imageVisualMap1.URL = "./NUISample/res/images/image-1.jpg";
+ /// imageVisualMap1.VisualSize = new Vector2( 300.0f, 300.0f );
+ /// imageVisualMap1.Offset = new Vector2( 50.0f, 50.0f );
+ /// imageVisualMap1.OffsetSizeMode = new Vector4( 1.0f, 1.0f, 1.0f, 1.0f );
+ /// imageVisualMap1.Origin = AlignType.TOP_BEGIN;
+ /// imageVisualMap1.AnchorPoint = AlignType.TOP_BEGIN;
+ /// _visualView.AddVisual("imageVisual1", imageVisualMap1);
+ /// </code>
+ /// </example>
public class VisualView : CustomView
{
//private LinkedList<VisualBase> _visualList = null;
/// 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>
- /// Note! As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored).<br>
/// </summary>
+ /// <remarks>As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored)</remarks>
/// <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>
public override void OnRelayout(Vector2 size, RelayoutContainer container)
{
View ret = View.DownCast(new Actor(NDalicManualPINVOKE.FocusManager_GetCurrentFocusActor(swigCPtr), true));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ if (ret.HasBody() == false)
+ {
+ return null;
+ }
return ret;
}
{
View ret = View.DownCast(new Actor(NDalicManualPINVOKE.FocusManager_GetFocusGroup(swigCPtr, Actor.getCPtr(view)), true));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ if (ret.HasBody() == false)
+ {
+ return null;
+ }
return ret;
}
{
View ret = View.DownCast(new Actor(NDalicManualPINVOKE.FocusManager_GetFocusIndicatorActor(swigCPtr), true));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ if (ret.HasBody() == false)
+ {
+ return null;
+ }
return ret;
}
/// <param name="value">A value</param>
public void Add(float progress, object value)
{
- dynamic obj = value;
- Add(progress, new PropertyValue(obj));
+ PropertyValue val = PropertyValue.CreateFromObject(value);
+ Add(progress, val);
}
/// <summary>
/// <param name="alpha">The alpha function used to blend to the next keyframe</param>
public void Add(float progress, object value, AlphaFunction alpha)
{
- dynamic obj = value;
- Add(progress, new PropertyValue(obj), alpha);
+ PropertyValue val = PropertyValue.CreateFromObject(value);
+ Add(progress, val, alpha);
}
/// <summary>
private void LOG(string _str)
{
//Tizen.Log.Debug("NUI", _str);
- //Console.WriteLine("[NUI]" + _str);
+ //Tizen.Log.Debug("NUI", "[NUI]" + _str);
}
/// <summary>
if (type.Equals(typeof(int)))
{
- System.Console.WriteLine(" got an int property value ");
+ Tizen.Log.Debug("NUI", " got an int property value ");
value = new PropertyValue((int)obj);
}
if (type.Equals(typeof(System.Int32)))
{
- System.Console.WriteLine(" got an int property value ");
+ Tizen.Log.Debug("NUI", " got an int property value ");
value = new PropertyValue((int)obj);
}
else if (type.Equals(typeof(bool)))
{
- System.Console.WriteLine(" got an bool property value ");
+ Tizen.Log.Debug("NUI", " got an bool property value ");
value = new PropertyValue((bool)obj);
}
else if (type.Equals(typeof(float)))
{
- System.Console.WriteLine(" got an float property value ");
+ Tizen.Log.Debug("NUI", " got an float property value ");
value = new PropertyValue((float)obj);
}
else if (type.Equals(typeof(string)))
{
- System.Console.WriteLine(" got a string property value ");
+ Tizen.Log.Debug("NUI", " got a string property value ");
value = new PropertyValue((string)obj);
}
else if (type.Equals(typeof(Vector2)))
{
- System.Console.WriteLine(" got an Vector2 property value ");
+ Tizen.Log.Debug("NUI", " got an Vector2 property value ");
value = new PropertyValue((Vector2)obj);
}
else if (type.Equals(typeof(Vector3)))
{
- System.Console.WriteLine(" got an Vector3 property value ");
+ Tizen.Log.Debug("NUI", " got an Vector3 property value ");
value = new PropertyValue((Vector3)obj);
}
else if (type.Equals(typeof(Vector4)))
{
- System.Console.WriteLine(" got an Vector4 property value ");
+ Tizen.Log.Debug("NUI", " got an Vector4 property value ");
value = new PropertyValue((Vector4)obj);
}
else if (type.Equals(typeof(Position)))
{
- System.Console.WriteLine(" got an Position property value ");
+ Tizen.Log.Debug("NUI", " got an Position property value ");
value = new PropertyValue((Position)obj);
}
+ else if (type.Equals(typeof(Position2D)))
+ {
+ Tizen.Log.Debug("NUI", " got an Position2D property value ");
+ value = new PropertyValue((Position2D)obj);
+ }
else if (type.Equals(typeof(Size)))
{
- System.Console.WriteLine(" got an Size property value ");
+ Tizen.Log.Debug("NUI", " got an Size property value ");
value = new PropertyValue((Size)obj);
}
+ else if (type.Equals(typeof(Size2D)))
+ {
+ Tizen.Log.Debug("NUI", " got an Size2D property value ");
+ value = new PropertyValue((Size2D)obj);
+ }
else if (type.Equals(typeof(Color)))
{
- System.Console.WriteLine(" got an Color property value ");
+ Tizen.Log.Debug("NUI", " got an Color property value ");
value = new PropertyValue((Color)obj);
}
+ else if (type.Equals(typeof(Rotation)))
+ {
+ Tizen.Log.Debug("NUI", " got an Rotation property value ");
+ value = new PropertyValue((Rotation)obj);
+ }
+ else if (type.Equals(typeof(RelativeVector2)))
+ {
+ Tizen.Log.Debug("NUI", " got an RelativeVector2 property value ");
+ value = new PropertyValue((RelativeVector2)obj);
+ }
+ else if (type.Equals(typeof(RelativeVector3)))
+ {
+ Tizen.Log.Debug("NUI", " got an RelativeVector3 property value ");
+ value = new PropertyValue((RelativeVector3)obj);
+ }
+ else if (type.Equals(typeof(RelativeVector4)))
+ {
+ Tizen.Log.Debug("NUI", " got an RelativeVector4 property value ");
+ value = new PropertyValue((RelativeVector4)obj);
+ }
else
{
- throw new global::System.InvalidOperationException("Unimplemented type for Property Value");
+ throw new global::System.InvalidOperationException("Unimplemented type for Property Value :" + type.Name);
}
return value;
}
}
/// <summary>
- /// This specifies all the property types.
+ /// This specifies all the property types. <br>
+ /// Enumeration for the property types supported.
/// </summary>
public enum PropertyType
{
+ /// <summary>
+ /// No type
+ /// </summary>
None,
+ /// <summary>
+ /// A boolean type
+ /// </summary>
Boolean,
+ /// <summary>
+ /// A float type
+ /// </summary>
Float,
+ /// <summary>
+ /// An integer type
+ /// </summary>
Integer,
+ /// <summary>
+ /// a vector array of size=2 with float precision
+ /// </summary>
Vector2,
+ /// <summary>
+ /// a vector array of size=3 with float precision
+ /// </summary>
Vector3,
+ /// <summary>
+ /// a vector array of size=4 with float precision
+ /// </summary>
Vector4,
+ /// <summary>
+ /// a 3x3 matrix
+ /// </summary>
Matrix3,
+ /// <summary>
+ /// a 4x4 matrix
+ /// </summary>
Matrix,
+ /// <summary>
+ /// an integer array of size=4
+ /// </summary>
Rectangle,
+ /// <summary>
+ /// either a quaternion or an axis angle rotation
+ /// </summary>
Rotation,
+ /// <summary>
+ /// A string type
+ /// </summary>
String,
+ /// <summary>
+ /// an array of PropertyValue
+ /// </summary>
Array,
+ /// <summary>
+ /// a string key to PropertyValue mapping
+ /// </summary>
Map
}
/// <summary>
- /// This specifies the property access mode types.
+ /// This specifies the property access mode types. <br>
+ /// Enumeration for the access mode for custom properties.
/// </summary>
public enum PropertyAccessMode
{
+ /// <summary>
+ /// if the property is read-only
+ /// </summary>
ReadOnly,
+ /// <summary>
+ /// If the property is read/writeable
+ /// </summary>
ReadWrite,
+ /// <summary>
+ /// If the property can be animated or constrained
+ /// </summary>
Animatable,
+ /// <summary>
+ /// The number of access modes
+ /// </summary>
AccessModeCount
}
using System.Runtime.InteropServices;
/// <summary>
- /// StyleManager informs applications of system theme change,
- /// and supports application theme change at runtime.<br>
+ /// StyleManager informs applications of system theme change, and supports application theme change at runtime.<br>
/// Applies various styles to Controls using the properties system.<br>
- /// On theme change, it automatically updates all controls, then raises
- /// a event to inform the application.<br>
- /// <br>
- /// If the application wants to customize the theme, RequestThemeChange
- /// needs to be called.<br>
- /// It provides the path to the application resource root folder,
- /// from there the filename can an be specified along with
- /// any sub folders, e.g Images, Models etc.<br>
+ /// On theme change, it automatically updates all controls, then raises a event to inform the application.<br>
+ /// If the application wants to customize the theme, RequestThemeChange needs to be called.<br>
+ /// It provides the path to the application resource root folder, from there the filename can an be specified along with any sub folders, e.g Images, Models etc.<br>
/// </summary>
public class StyleManager : BaseHandle
{
}
/// <summary>
- /// Types of style change.
+ /// Types of style change. Enumeration for StyleChange type.
/// </summary>
public enum StyleChangeType
{
+ /// <summary>
+ /// Denotes that the default font has changed.
+ /// </summary>
DefaultFontChange,
+ /// <summary>
+ /// Denotes that the default font size has changed.
+ /// </summary>
DefaultFontSizeChange,
+ /// <summary>
+ /// Denotes that the theme has changed.
+ /// </summary>
ThemeChange
}
/// </summary>
public enum HorizontalAlignmentType
{
+ /// <summary>
+ /// Align horizontally left
+ /// </summary>
Left,
+ /// <summary>
+ /// Align horizontally center
+ /// </summary>
Center,
+ /// <summary>
+ /// Align horizontally right
+ /// </summary>
Right
}
/// </summary>
public enum VerticalAlignmentType
{
+ /// <summary>
+ /// Align vertically top
+ /// </summary>
Top,
+ /// <summary>
+ /// Align vertically center
+ /// </summary>
Center,
+ /// <summary>
+ /// Align vertically bottom
+ /// </summary>
Bottom
}
/// </summary>
public enum PointStateType
{
+ /// <summary>
+ /// Touch or hover started
+ /// </summary>
Started,
+ /// <summary>
+ /// Touch or hover finished
+ /// </summary>
Finished,
+ /// <summary>
+ /// Screen touched
+ /// </summary>
Down = Started,
+ /// <summary>
+ /// Touch stopped
+ /// </summary>
Up = Finished,
+ /// <summary>
+ /// Finger dragged or hovered
+ /// </summary>
Motion,
+ /// <summary>
+ /// Leave the boundary of an actor
+ /// </summary>
Leave,
+ /// <summary>
+ /// No change from last event. <br>
+ /// Useful when a multi-point event occurs where all points are sent but indicates that this particular point has not changed since the last time.
+ /// </summary>
Stationary,
+ /// <summary>
+ /// A system event has occurred which has interrupted the touch or hover event sequence.
+ /// </summary>
Interrupted
}
/// <summary>
- /// Describes the direction to move the keyboard focus towards.
+ /// Describes the direction to move the focus towards.
/// </summary>
public enum FocusDirection
{
/// 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>
/// Each visual also responds to actor size and color change, and provides clipping at the renderer level.<br>
- /// Note: The visual responds to the the Actor::COLOR by blending it with the 'Multiply' operator.<br>
/// </summary>
public class VisualBase : BaseHandle
{
private float _depthIndex = 0.0f;
protected PropertyMap _outputVisualMap = null;
+
internal string Name
{
set;
}
}
+ protected PropertyMap _shader = null;
+ //private PropertyMap _transform = null;
+ protected bool? _premultipliedAlpha = null;
+ protected Color _mixColor = null;
+ protected float? _opacity = null;
+ protected PropertyMap _commonlyUsedMap = null;
+
+ /// <summary>
+ /// The shader to use in the visual.
+ /// </summary>
+ public PropertyMap Shader
+ {
+ get
+ {
+ return _shader;
+ }
+ set
+ {
+ _shader = value;
+ UpdateVisual();
+ }
+ }
+ /// <summary>
+ /// Enables/disables premultiplied alpha. <br>
+ /// The premultiplied alpha is false by default unless this behaviour is modified by the derived Visual type.
+ /// </summary>
+ public bool PremultipliedAlpha
+ {
+ get
+ {
+ return _premultipliedAlpha??false;
+ }
+ set
+ {
+ _premultipliedAlpha = value;
+ UpdateVisual();
+ }
+ }
+ /// <summary>
+ /// Mix color is a blend color for any visual.
+ /// </summary>
+ public Color MixColor
+ {
+ get
+ {
+ return _mixColor;
+ }
+ set
+ {
+ _mixColor = value;
+ UpdateVisual();
+ }
+ }
+ /// <summary>
+ /// Opacity is the alpha component of the mixColor, above.
+ /// </summary>
+ public float Opacity
+ {
+ get
+ {
+ return _opacity??(-1.0f);
+ }
+ set
+ {
+ _opacity = value;
+ UpdateVisual();
+ }
+ }
+
}
/// <summary>
if (_pixelArea != null) { _outputVisualMap.Add(ImageVisualProperty.PixelArea, new PropertyValue(_pixelArea)); }
if (_wrapModeU != null) { _outputVisualMap.Add(ImageVisualProperty.WrapModeU, new PropertyValue((int)_wrapModeU)); }
if (_wrapModeV != null) { _outputVisualMap.Add(ImageVisualProperty.WrapModeV, new PropertyValue((int)_wrapModeV)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
-
}
/// <summary>
if (_verticalAlignment != null) { _outputVisualMap.Add(TextVisualProperty.VerticalAlignment, new PropertyValue(_verticalAlignment)); }
if (_textColor != null) { _outputVisualMap.Add(TextVisualProperty.TextColor, new PropertyValue(_textColor)); }
if (_enableMarkup != null) { _outputVisualMap.Add(TextVisualProperty.EnableMarkup, new PropertyValue((bool)_enableMarkup)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
if (_color != null) { _outputVisualMap.Add(BorderVisualProperty.Color, new PropertyValue(_color)); }
if (_size != null) { _outputVisualMap.Add(BorderVisualProperty.Size, new PropertyValue((float)_size)); }
if (_antiAliasing != null) { _outputVisualMap.Add(BorderVisualProperty.AntiAliasing, new PropertyValue((bool)_antiAliasing)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
{
}
- private Color _mixColor = null;
+ private Color _mixColorForColorVisual = null;
/// <summary>
/// Get or set the solid color required.
/// </summary>
- public Color MixColor
+ public Color Color
{
get
{
- return _mixColor;
+ return _mixColorForColorVisual;
}
set
{
- _mixColor = value;
+ _mixColorForColorVisual = value;
UpdateVisual();
}
}
{
_outputVisualMap = new PropertyMap();
_outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Color));
- if (_mixColor != null) { _outputVisualMap.Add(ColorVisualProperty.MixColor, new PropertyValue(_mixColor)); }
+ if (_mixColorForColorVisual != null) { _outputVisualMap.Add(ColorVisualProperty.MixColor, new PropertyValue(_mixColorForColorVisual)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
if (_stopColor != null) { _outputVisualMap.Add(GradientVisualProperty.StopColor, new PropertyValue(_stopColor)); }
if (_units != null) { _outputVisualMap.Add(GradientVisualProperty.Units, new PropertyValue((int)_units)); }
if (_spreadMethod != null) { _outputVisualMap.Add(GradientVisualProperty.SpreadMethod, new PropertyValue((int)_spreadMethod)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
if (_shadingMode != null) { _outputVisualMap.Add(MeshVisualProperty.ShadingMode, new PropertyValue((int)_shadingMode)); }
if (_useMipmapping != null) { _outputVisualMap.Add(MeshVisualProperty.UseMipmapping, new PropertyValue((bool)_useMipmapping)); }
if (_useSoftNormals != null) { _outputVisualMap.Add(MeshVisualProperty.UseSoftNormals, new PropertyValue((bool)_useSoftNormals)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
+
}
}
}
private PrimitiveVisualShapeType? _shape = null;
- private Color _mixColor = null;
+ private Color _mixColorForPrimitiveVisual = null;
private int? _slices = null;
private int? _stacks = null;
private float? _scaleTopRadius = null;
{
get
{
- return _mixColor;
+ return _mixColorForPrimitiveVisual;
}
set
{
- _mixColor = value;
+ _mixColorForPrimitiveVisual = value;
UpdateVisual();
}
}
_outputVisualMap = new PropertyMap(); ;
_outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.Primitive));
if (_shape != null) { _outputVisualMap.Add(PrimitiveVisualProperty.Shape, new PropertyValue((int)_shape)); }
- if (_mixColor != null) { _outputVisualMap.Add(PrimitiveVisualProperty.MixColor, new PropertyValue(_mixColor)); }
+ if (_mixColorForPrimitiveVisual != null) { _outputVisualMap.Add(PrimitiveVisualProperty.MixColor, new PropertyValue(_mixColorForPrimitiveVisual)); }
if (_slices != null) { _outputVisualMap.Add(PrimitiveVisualProperty.Slices, new PropertyValue((int)_slices)); }
if (_stacks != null) { _outputVisualMap.Add(PrimitiveVisualProperty.Stacks, new PropertyValue((int)_stacks)); }
if (_scaleTopRadius != null) { _outputVisualMap.Add(PrimitiveVisualProperty.ScaleTopRadius, new PropertyValue((float)_scaleTopRadius)); }
if (_bevelPercentage != null) { _outputVisualMap.Add(PrimitiveVisualProperty.BevelPercentage, new PropertyValue((float)_bevelPercentage)); }
if (_bevelSmoothness != null) { _outputVisualMap.Add(PrimitiveVisualProperty.BevelSmoothness, new PropertyValue((float)_bevelSmoothness)); }
if (_lightPosition != null) { _outputVisualMap.Add(PrimitiveVisualProperty.LightPosition, new PropertyValue(_lightPosition)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
if (_url != null) { _outputVisualMap.Add(NpatchImageVisualProperty.URL, new PropertyValue(_url)); }
if (_borderOnly != null) { _outputVisualMap.Add(NpatchImageVisualProperty.BorderOnly, new PropertyValue((bool)_borderOnly)); }
if (_border != null) { _outputVisualMap.Add(NpatchImageVisualProperty.Border, new PropertyValue(_border)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
+
}
}
/// <summary>
- /// This specifies wrap mode types
+ /// This specifies wrap mode types <br>
+ /// WrapModeU and WrapModeV separately decide how the texture should be sampled when the u and v coordinate exceeds the range of 0.0 to 1.0.
/// </summary>
public enum WrapModeType
{
+ /// <summary>
+ /// Defualt value
+ /// </summary>
Default = 0,
+ /// <summary>
+ /// Clamp to edge
+ /// </summary>
ClampToEdge,
+ /// <summary>
+ /// Repeat
+ /// </summary>
Repeat,
+ /// <summary>
+ /// Mirrored repeat
+ /// </summary>
MirroredRepeat
}
/// <summary>
- /// This specifies all kind os types of coordinate system for certain attributes of the points in a gradient.
+ /// The type of coordinate system for certain attributes of the points in a gradient.
/// </summary>
public enum GradientVisualUnitsType
{
+ /// <summary>
+ /// Uses the normals for the start, end & center points, i.e. top-left is (-0.5, -0.5) and bottom-right is (0.5, 0.5).
+ /// </summary>
ObjectBoundingBox,
+ /// <summary>
+ /// Uses the user coordinates for the start, end & center points, i.e. in a 200 by 200 control, top-left is (0, 0) and bottom-right is (200, 200).
+ /// </summary>
UserSpace
}
/// </summary>
public enum GradientVisualSpreadMethodType
{
+ /// <summary>
+ /// Uses the terminal colors of the gradient to fill the remainder of the quad.
+ /// </summary>
Pad,
+ /// <summary>
+ /// Reflect the gradient pattern start-to-end, end-to-start, start-to-end etc. until the quad is filled.
+ /// </summary>
Reflect,
+ /// <summary>
+ /// Repeat the gradient pattern start-to-end, start-to-end, start-to-end etc. until the quad is filled.
+ /// </summary>
Repeat
}
/// <summary>
- /// This specifies shading mode types.
+ /// The shading mode used by MeshVisual.
/// </summary>
public enum MeshVisualShadingModeValue
{
+ /// <summary>
+ /// *Simplest*. One color that is lit by ambient and diffuse lighting.
+ /// </summary>
TexturelessWithDiffuseLighting,
+ /// <summary>
+ /// Uses only the visual image textures provided with specular lighting in addition to ambient and diffuse lighting.
+ /// </summary>
TexturedWithSpecularLighting,
+ /// <summary>
+ /// Uses all textures provided including a gloss, normal and texture map along with specular, ambient and diffuse lighting.
+ /// </summary>
TexturedWithDetailedSpecularLighting
}
/// <summary>
- /// This specifies shape types.
+ /// The primitive shape to render as a PrimitiveVisual.
/// </summary>
public enum PrimitiveVisualShapeType
{
+ /// <summary>
+ /// A perfectly round geometrical object in three-dimensional space.
+ /// </summary>
Sphere,
+ /// <summary>
+ /// The area bound between two circles, i.e. a cone with the tip removed.
+ /// </summary>
ConicalFrustrum,
+ /// <summary>
+ /// Equivalent to a conical frustrum with top radius of zero.
+ /// </summary>Equivalent to a conical frustrum with top radius of zero.
Cone,
+ /// <summary>
+ /// Equivalent to a conical frustrum with top radius of zero.
+ /// </summary>
Cylinder,
+ /// <summary>
+ /// Equivalent to a conical frustrum with equal radii for the top and bottom circles.
+ /// </summary>
Cube,
+ /// <summary>
+ /// Equivalent to a bevelled cube with a bevel percentage of zero.
+ /// </summary>
Octahedron,
+ /// <summary>
+ /// Equivalent to a bevelled cube with a bevel percentage of one.
+ /// </summary>
BevelledCube
}
/// </summary>
public enum FittingModeType
{
+ /// <summary>
+ /// Full-screen image display: Limit loaded image resolution to device resolution using ShrinkToFit mode.
+ /// </summary>
ShrinkToFit,
+ /// <summary>
+ /// Thumbnail gallery grid: Limit loaded image resolution to screen tile using ScaleToFill mode.
+ /// </summary>
ScaleToFill,
+ /// <summary>
+ /// Image columns: Limit loaded image resolution to column width using FitWidth mode.
+ /// </summary>
FitWidth,
+ /// <summary>
+ /// Image rows: Limit loaded image resolution to row height using FitHeight mode.
+ /// </summary>
FitHeight
}
/// <summary>
/// This specifies sampling mode types. Filtering options, used when resizing images to sample original pixels.<br>
/// A SamplingMode controls how pixels in an input image are sampled and combined to generate each pixel of a destination image during a scaling.<br>
- /// NoFilter and Box modes do not guarantee that the output pixel array exactly matches the rectangle specified by the desired dimensions and FittingMode,
+ /// NoFilter and Box modes do not guarantee that the output pixel array exactly matches the rectangle specified by the desired dimensions and FittingMode,<br>
/// but all other filter modes do if the desired dimensions are `<=` the raw dimensions of the input image file.<br>
/// </summary>
public enum SamplingModeType
{
+ /// <summary>
+ /// Iteratively box filter to generate an image of 1/2, 1/4, 1/8, etc width and height and approximately the desired size. <br>
+ /// This is the default.
+ /// </summary>
Box,
+ /// <summary>
+ /// For each output pixel, read one input pixel.
+ /// </summary>
Nearest,
+ /// <summary>
+ /// For each output pixel, read a quad of four input pixels and write a weighted average of them.
+ /// </summary>
Linear,
+ /// <summary>
+ /// Iteratively box filter to generate an image of 1/2, 1/4, 1/8 etc width and height and approximately the desired size, <br>
+ /// then for each output pixel, read one pixel from the last level of box filtering.<br>
+ /// </summary>
BoxThenNearest,
+ /// <summary>
+ /// Iteratively box filter to almost the right size, then for each output pixel, read four pixels from the last level of box filtering and write their weighted average.
+ /// </summary>
BoxThenLinear,
+ /// <summary>
+ /// No filtering is performed. If the SCALE_TO_FILL scaling mode is enabled, the borders of the image may be trimmed to match the aspect ratio of the desired dimensions.
+ /// </summary>
NoFilter,
+ /// <summary>
+ /// For caching algorithms where a client strongly prefers a cache-hit to reuse a cached image.
+ /// </summary>
DontCare
}
/// </summary>
public enum VisualTransformPolicyType
{
+ /// <summary>
+ /// Relative to the control (percentage [0.0f to 1.0f] of the control).
+ /// </summary>
Relative = 0,
+ /// <summary>
+ /// Absolute value in world units.
+ /// </summary>
Absolute = 1
}
/// </summary>
public enum VisualTransformPropertyType
{
+ /// <summary>
+ /// Offset of the visual, which can be either relative (percentage [0.0f to 1.0f] of the parent) or absolute (in world units).
+ /// </summary>
Offset,
+ /// <summary>
+ /// Size of the visual, which can be either relative (percentage [0.0f to 1.0f] of the parent) or absolute (in world units).
+ /// </summary>
Size,
+ /// <summary>
+ /// The origin of the visual within its control area.
+ /// </summary>
Origin,
+ /// <summary>
+ /// The anchor-point of the visual
+ /// </summary>
AnchorPoint,
+ /// <summary>
+ /// Whether the x or y OFFSET values are relative (percentage [0.0f to 1.0f] of the control) or absolute (in world units).
+ /// </summary>
OffsetPolicy,
+ /// <summary>
+ /// Whether the width or height SIZE values are relative (percentage [0.0f to 1.0f] of the control) or absolute (in world units).
+ /// </summary>
SizePolicy
}
/// </summary>
public struct Visual
{
+ /// <summary>
+ /// The index for the visual type.
+ /// </summary>
public enum Type
{
+ /// <summary>
+ /// Renders a solid color as an internal border to the control's quad.
+ /// </summary>
Border,
+ /// <summary>
+ /// Renders a solid color to the control's quad.
+ /// </summary>
Color,
+ /// <summary>
+ /// Renders a smooth transition of colors to the control's quad.
+ /// </summary>
Gradient,
+ /// <summary>
+ /// Renders an image into the control's quad.
+ /// </summary>
Image,
+ /// <summary>
+ /// Renders a mesh using an "obj" file, optionally with textures provided by an "mtl" file.
+ /// </summary>
Mesh,
+ /// <summary>
+ /// Renders a simple 3D shape, such as a cube or sphere.
+ /// </summary>
Primitive,
+ /// <summary>
+ /// Renders a simple wire-frame outlining a quad.
+ /// </summary>
Wireframe,
+ /// <summary>
+ /// Renders text.
+ /// </summary>
Text,
+ /// <summary>
+ /// Renders an n-patch image.
+ /// </summary>
NPatch,
+ /// <summary>
+ /// Renders an SVG image.
+ /// </summary>
SVG,
+ /// <summary>
+ /// Renders a animated image. (Animated GIF)
+ /// </summary>
AnimatedImage
}
public static readonly int Transform = NDalic.VISUAL_PROPERTY_TRANSFORM;
public static readonly int PremultipliedAlpha = NDalic.VISUAL_PROPERTY_PREMULTIPLIED_ALPHA;
public static readonly int MixColor = NDalic.VISUAL_PROPERTY_MIX_COLOR;
+ public static readonly int Opacity = NDalic.VISUAL_PROPERTY_MIX_COLOR + 1;
}
/// <summary>
_outputVisualMap = new PropertyMap();
_outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.SVG));
if (_url != null) { _outputVisualMap.Add(ImageVisualProperty.URL, new PropertyValue(_url)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
_outputVisualMap = new PropertyMap();
_outputVisualMap.Add(Visual.Property.Type, new PropertyValue((int)Visual.Type.AnimatedImage));
if (_url != null) { _outputVisualMap.Add(ImageVisualProperty.URL, new PropertyValue(_url)); }
+ if (_shader != null) { _outputVisualMap.Add((int)Visual.Property.Shader, new PropertyValue(_shader)); }
+ if (_premultipliedAlpha != null) { _outputVisualMap.Add((int)Visual.Property.PremultipliedAlpha, new PropertyValue((bool)_premultipliedAlpha)); }
+ if (_mixColor != null) { _outputVisualMap.Add((int)Visual.Property.MixColor, new PropertyValue(_mixColor)); }
+ if (_opacity != null) { _outputVisualMap.Add((int)Visual.Property.Opacity, new PropertyValue((float)_opacity)); }
}
}
string _str1 = _propertyIndex.Substring(0, 1);
string _str2 = _propertyIndex.Substring(1);
string _str = _str1.ToLower() + _str2;
-
- //dynamic _obj = (object)_destinationValue;
+
PropertyValue val = PropertyValue.CreateFromObject(_destinationValue);
PropertyMap _transition = new PropertyMap();
_transition.Add("target", new PropertyValue(_target));
_transition.Add("property", new PropertyValue(_str));
- _transition.Add("targetValue", new PropertyValue(val));
+ _transition.Add("targetValue", val);
_transition.Add("animator", new PropertyValue(_animator));
_outputVisualMap = _transition;
{
/// <summary>
- /// 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>
- /// <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>
- /// <br>
+ /// 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>
/// </summary>
projects / platform / core / csapi / tizenfx.git / commitdiff