-// 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
+/*
+ * 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.
+ *
+ */
namespace Tizen.NUI
{
using System.Runtime.InteropServices;
using Tizen.NUI.BaseComponents;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.Linq;
+ using System.Reflection;
+ using System.Xml;
+ using Tizen.NUI.Binding.Internals;
+ using Tizen.NUI.Binding;
+ using System.Globalization;
+ using Tizen.NUI.Xaml.Internals;
+
/// <summary>
- /// Animation can be used to animate the properties of any number of objects, typically View.<br>
- /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.<br>
- /// This is typically done in the object destructor, and requires either the Animation handle to be stored.<br>
- /// The overall animation time is superseded by the values given in the animation time used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.<br>
- /// If any of the individual calls to those functions exceeds the overall animation time(Duration), then the overall animation time is automatically extended.<br>
+ /// Animation can be used to animate the properties of any number of objects, typically view.<br />
+ /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.<br />
+ /// This is typically done in the object destructor, and requires either the animation handle to be stored.<br />
+ /// The overall animation time is superseded by the values given in the animation time used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.<br />
+ /// 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>
+ /// <since_tizen> 3 </since_tizen>
public class Animation : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
internal Animation(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Animation_SWIGUpcast(cPtr), cMemoryOwn)
{
swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+
+ _animationFinishedEventCallback = OnFinished;
+ _finishedCallbackOfNative = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(_animationFinishedEventCallback);
}
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animation obj)
}
/// <summary>
- /// To make Animation instance be disposed.
+ /// To make animation instance be disposed.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
protected override void Dispose(DisposeTypes type)
{
+ if (this != null)
+ {
+ if (_animationFinishedEventCallback != null)
+ {
+ FinishedSignal().Disconnect(_finishedCallbackOfNative);
+ }
+
+ if (_animationProgressReachedEventCallback != null)
+ {
+
+ ProgressReachedSignal().Disconnect(_animationProgressReachedEventCallback);
+ }
+ }
+
if(disposed)
{
return;
}
- if(this)
+ if (this != null)
{
this.Clear();
- this.Reset();
- NUILog.Error("Now Animation is playing! Clear and Reset here!");
- //throw new System.InvalidOperationException("Animation Instance should not be disposed until getting Finished event. Should be a global variable");
}
-
//Release your own unmanaged resources here.
//You should not access any managed member here except static instance.
//because the execution order of Finalizes is non-deterministic.
}
/// <summary>
- /// Create an initialized Animation.<br>
- /// The animation will not loop.<br>
- /// The default end action is "Cancel".<br>
- /// The default Alpha function is linear.<br>
+ /// Creates an initialized animation.<br />
+ /// The animation will not loop.<br />
+ /// The default end action is "Cancel".<br />
+ /// The default alpha function is linear.<br />
/// </summary>
/// <remarks>DurationmSeconds must be greater than zero.</remarks>
- /// <param name="durationMilliSeconds">The duration in milli seconds.</param>
+ /// <param name="durationMilliSeconds">The duration in milliseconds.</param>
+ /// <since_tizen> 3 </since_tizen>
public Animation(int durationMilliSeconds) : this(NDalicPINVOKE.Animation_New((float)durationMilliSeconds / 1000.0f), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void AnimationFinishedEventCallbackType(IntPtr data);
private event EventHandler _animationFinishedEventHandler;
+
+ private System.IntPtr _finishedCallbackOfNative;
+
/**
- * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler.
- * Finished signal is emitted when an Animation's animations have finished.
+ * @brief Event for the finished signal which can be used to subscribe or unsubscribe the event handler.
+ * The finished signal is emitted when an animation's animations have finished.
*/
+ /// <since_tizen> 3 </since_tizen>
public event EventHandler Finished
{
add
{
- if (_animationFinishedEventHandler == null)
+ if (_animationFinishedEventHandler == null && disposed == false)
{
- NUILog.Debug("[add before]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
- _animationFinishedEventCallback = OnFinished;
- FinishedSignal().Connect(_animationFinishedEventCallback);
- NUILog.Debug("[add after]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
+ FinishedSignal().Connect(_finishedCallbackOfNative);
}
_animationFinishedEventHandler += value;
}
if (_animationFinishedEventHandler == null && FinishedSignal().Empty() == false)
{
- NUILog.Debug("[remove before]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
- FinishedSignal().Disconnect(_animationFinishedEventCallback);
- NUILog.Debug("[remove after]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
+ FinishedSignal().Disconnect(_finishedCallbackOfNative);
}
}
}
private AnimationProgressReachedEventCallbackType _animationProgressReachedEventCallback;
private event EventHandler _animationProgressReachedEventHandler;
/**
- * @brief Event for ProgressReached signal which can be used to subscribe/unsubscribe the event handler.
- * ProgressReached signal is emitted when the Animation has reached a given progress percentage, this is set in the api SetProgressNotification.
+ * @brief Event for the ProgressReached signal, which can be used to subscribe or unsubscribe the event handler.
+ * The ProgressReached signal is emitted when the animation has reached a given progress percentage, this is set in the api SetProgressNotification.
*/
+ /// <since_tizen> 3 </since_tizen>
public event EventHandler ProgressReached
{
add
{
if (_animationProgressReachedEventHandler == null)
{
- NUILog.Debug("[add before]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
_animationProgressReachedEventCallback = OnProgressReached;
ProgressReachedSignal().Connect(_animationProgressReachedEventCallback);
- NUILog.Debug("[add after]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
}
_animationProgressReachedEventHandler += value;
if (_animationProgressReachedEventHandler == null && ProgressReachedSignal().Empty() == false)
{
- NUILog.Debug("[remove before]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
- ProgressReachedSignal().Disconnect(_animationProgressReachedEventHandler);
- NUILog.Debug("[remove after]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
+ ProgressReachedSignal().Disconnect(_animationProgressReachedEventCallback);
}
}
}
/// <summary>
- /// Gets/Sets the duration in milli seconds of the animation.
+ /// Gets or sets the duration in milliseconds of the animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public int Duration
{
set
}
/// <summary>
- /// Gets/Sets the default alpha function for the animation.
+ /// Gets or sets the default alpha function for the animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public AlphaFunction DefaultAlphaFunction
{
set
/// <summary>
/// Queries the state of the animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public States State
{
get
}
/// <summary>
- /// Set : Enables looping for 'count' repeats. A zero is the same as Looping = true; i.e.repeat forever.<br>
- /// If Play() Stop() or 'count' loops is reached, the loop counter will reset.<br>
- /// Setting this parameter does not cause the animation to Play().<br>
- /// Get : Gets the loop count. A zero is the same as Looping = true; ie repeat forever.<br>
- /// The loop count is initially 1 for play once.<br>
+ /// Set: Enables looping for a specified number of repeats. A zero is the same as Looping = true; i.e., repeat forever.<br />
+ /// This property resets the looping value and should not be used with the Looping property.<br />
+ /// Setting this parameter does not cause the animation to Play().<br />
+ /// Get: Gets the loop count. A zero is the same as Looping = true; i.e., repeat forever.<br />
+ /// The loop count is initially 1 for play once.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public int LoopCount
{
set
}
/// <summary>
- /// Gets/Sets the status of whether the animation will loop.<br>
- /// This property resets the loop count and should not be used with LoopCount property.<br>
- /// Setting this parameter does not cause the animation to Play().<br>
+ /// Gets or sets the status of whether the animation will loop.<br />
+ /// This property resets the loop count and should not be used with the LoopCount property.<br />
+ /// Setting this parameter does not cause the animation to Play().<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public bool Looping
{
set
/// <summary>
- /// Gets/Sets the end action of the animation.<br>
- /// This action is performed when the animation ends or if it is stopped.<br>
- /// Default end action is Cancel.<br>
+ /// Gets or sets the end action of the animation.<br />
+ /// This action is performed when the animation ends or if it is stopped.<br />
+ /// The default end action is cancel.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public EndActions EndAction
{
set
/// <summary>
/// Stops the animation.
/// </summary>
- /// <param name="action">end action can be set</param>
+ /// <param name="action">The end action can be set.</param>
+ /// <since_tizen> 3 </since_tizen>
public void Stop(EndActions action = EndActions.Cancel)
{
SetEndAction(action);
}
/// <summary>
- /// Gets the current loop count.<br>
- /// A value 0 indicating the current loop count when looping.<br>
+ /// Gets the current loop count.<br />
+ /// A value 0 indicating the current loop count when looping.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public int CurrentLoop
{
get
}
/// <summary>
- /// Gets/Sets the disconnect action.<br>
- /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.<br>
- /// Default action is to Cancel.<br>
+ /// Gets or sets the disconnect action.<br />
+ /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.<br />
+ /// The default action is cancel.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public EndActions DisconnectAction
{
set
/// <summary>
- /// Gets/Sets the progress of the animation.<br>
- /// The animation will play(or continue playing) from this point.<br>
- /// The progress must be in the 0-1 interval or in the play range interval if defined.<br>
- /// otherwise, it will be ignored.<br>
+ /// Gets or sets the progress of the animation.<br />
+ /// The animation will play (or continue playing) from this point.<br />
+ /// The progress must be in the 0-1 interval or in the play range interval if defined<br />
+ /// otherwise, it will be ignored.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public float CurrentProgress
{
set
}
/// <summary>
- /// Gets/Sets Specifies a speed factor for the animation.<br>
- /// The speed factor is a multiplier of the normal velocity of the animation.<br>
- /// Values between[0, 1] will slow down the animation and values above one will speed up the animation.<br>
- /// It is also possible to specify a negative multiplier to play the animation in reverse.<br>
+ /// Gets or sets specificifications of a speed factor for the animation.<br />
+ /// The speed factor is a multiplier of the normal velocity of the animation.<br />
+ /// Values between [0, 1] will slow down the animation and values above one will speed up the animation.<br />
+ /// It is also possible to specify a negative multiplier to play the animation in reverse.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public float SpeedFactor
{
set
}
/// <summary>
- /// Gets/Sets the playing range.<br>
- /// 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.<br>
+ /// Gets or sets the playing range.<br />
+ /// 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.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public RelativeVector2 PlayRange
{
set
/// <summary>
- /// Gets/Sets the Progress notification marker which triggers the ProgressReachedSignal.<br>
- /// percentage of animation progress should be greater than 0 and less than 1, e.g 0.3 for 30% <br>
- /// One notification can be set on each animation
+ /// Gets or sets the progress notification marker which triggers the ProgressReachedSignal.<br />
+ /// Percentage of animation progress should be greater than 0 and less than 1, for example, 0.3 for 30% <br />
+ /// One notification can be set on each animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public float ProgressNotification
{
set
}
/// <summary>
- /// Animates a property value by a relative amount.<br>
+ /// Animates a property value by a relative amount.<br />
/// </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>
+ /// <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>
+ /// <since_tizen> 3 </since_tizen>
public void AnimateBy(View target, string property, object relativeValue, AlphaFunction alphaFunction = null)
{
- string _str1 = property.Substring(0, 1);
- string _str2 = property.Substring(1);
- string _str = _str1.ToLower() + _str2;
-
- Property _prop = new Property(target, _str);
- if (_prop.propertyIndex == Property.INVALID_INDEX)
- {
- throw new System.ArgumentException("second argument string property is invalid parameter!");
- }
+ Property _prop = PropertyHelper.GetPropertyFromString(target, property);
PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
if(propertyType.Equals(PropertyType.Float))
}
/// <summary>
- /// Animates a property value by a relative amount.<br>
+ /// Animates a property value by a relative amount.<br />
/// </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>
+ /// <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">The start time of the animation.</param>
+ /// <param name="endTime">The end time of the animation.</param>
+ /// <param name="alphaFunction">The alpha function to apply.</param>
+ /// <since_tizen> 3 </since_tizen>
public void AnimateBy(View target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
- string _str1 = property.Substring(0, 1);
- string _str2 = property.Substring(1);
- string _str = _str1.ToLower() + _str2;
-
- Property _prop = new Property(target, _str);
- if (_prop.propertyIndex == Property.INVALID_INDEX)
- {
- throw new System.ArgumentException("second argument string property is invalid parameter!");
- }
+ Property _prop = PropertyHelper.GetPropertyFromString(target, property);
PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
if(propertyType.Equals(PropertyType.Float))
}
/// <summary>
- /// Animates a property to a destination value.<br>
+ /// Animates a property to a destination value.<br />
/// </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="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>
+ /// <since_tizen> 3 </since_tizen>
public void AnimateTo(View target, string property, object destinationValue, AlphaFunction alphaFunction = null)
{
- string _str1 = property.Substring(0, 1);
- string _str2 = property.Substring(1);
- string _str = _str1.ToLower() + _str2;
-
- Property _prop = new Property(target, _str);
- if (_prop.propertyIndex == Property.INVALID_INDEX)
- {
- throw new System.ArgumentException("second argument string property is invalid parameter!");
- }
+ Property _prop = PropertyHelper.GetPropertyFromString(target, property);
PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
if(propertyType.Equals(PropertyType.Float))
AnimateTo(_prop, val);
}
}
+ private string[] _properties = null;
+ public string[] Properties
+ {
+ get
+ {
+ return _properties;
+ }
+ set
+ {
+ _properties = value;
+ }
+ }
- /// <summary>
- /// Animates a property to a destination value.<br>
- /// </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">The alpha function to apply</param>
- public void AnimateTo(View target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
+ private string[] _destValue = null;
+ public string[] DestValue
+ {
+ get
+ {
+ return _destValue;
+ }
+ set
+ {
+ _destValue = value;
+ }
+ }
+
+ private int[] _startTime = null;
+ public int[] StartTime
{
- string _str1 = property.Substring(0, 1);
- string _str2 = property.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ get
+ {
+ return _startTime;
+ }
+ set
+ {
+ _startTime = value;
+ }
+ }
- Property _prop = new Property(target, _str);
- if (_prop.propertyIndex == Property.INVALID_INDEX)
+ private int[] _endTime = null;
+ public int[] EndTime
+ {
+ get
{
- throw new System.ArgumentException("second argument string property is invalid parameter!");
+ return _endTime;
+ }
+ set
+ {
+ _endTime = value;
+ }
+ }
+
+ public void PlayAnimateTo(View target)
+ {
+ if (_properties.Length == _destValue.Length && _startTime.Length == _endTime.Length && _properties.Length == _startTime.Length)
+ {
+ int length = _properties.Length;
+ for (int index = 0; index < length; index++)
+ {
+ //object destinationValue = _destValue[index];
+ var elementType = target.GetType();
+ PropertyInfo propertyInfo = elementType.GetProperties().FirstOrDefault(fi => fi.Name == _properties[index]);
+ //var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localName);
+ if (propertyInfo != null)
+ {
+ object destinationValue = ConvertTo(_destValue[index], propertyInfo.PropertyType);
+
+ if(destinationValue != null)
+ {
+ AnimateTo(target, _properties[index], destinationValue, _startTime[index], _endTime[index]);
+ }
+ }
+ }
+ Play();
}
+ }
+
+ internal object ConvertTo(object value, Type toType)
+ {
+ Func<object> getConverter = () =>
+ {
+ MemberInfo memberInfo;
+
+ string converterTypeName = GetTypeConverterTypeName(toType.GetTypeInfo().CustomAttributes);
+ if (converterTypeName == null)
+ return null;
+
+ Type convertertype = Type.GetType(converterTypeName);
+ return Activator.CreateInstance(convertertype);
+ };
+
+ return ConvertTo(value, toType, getConverter);
+ }
+
+ internal object ConvertTo(object value, Type toType, Func<object> getConverter)
+ {
+ if (value == null)
+ return null;
+
+ var str = value as string;
+ if (str != null)
+ {
+ //If there's a [TypeConverter], use it
+ object converter = getConverter?.Invoke();
+ var xfTypeConverter = converter as TypeConverter;
+ if (xfTypeConverter != null)
+ return value = xfTypeConverter.ConvertFromInvariantString(str);
+ var converterType = converter?.GetType();
+ if (converterType != null)
+ {
+ var convertFromStringInvariant = converterType.GetRuntimeMethod("ConvertFromInvariantString",
+ new[] { typeof(string) });
+ if (convertFromStringInvariant != null)
+ return value = convertFromStringInvariant.Invoke(converter, new object[] { str });
+ }
+
+ //If the type is nullable, as the value is not null, it's safe to assume we want the built-in conversion
+ if (toType.GetTypeInfo().IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>))
+ toType = Nullable.GetUnderlyingType(toType);
+
+ //Obvious Built-in conversions
+ if (toType.GetTypeInfo().IsEnum)
+ return Enum.Parse(toType, str, true);
+ if (toType == typeof(SByte))
+ return SByte.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Int16))
+ return Int16.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Int32))
+ return Int32.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Int64))
+ return Int64.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Byte))
+ return Byte.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(UInt16))
+ return UInt16.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(UInt32))
+ return UInt32.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(UInt64))
+ return UInt64.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Single))
+ return Single.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Double))
+ return Double.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Boolean))
+ return Boolean.Parse(str);
+ if (toType == typeof(TimeSpan))
+ return TimeSpan.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(DateTime))
+ return DateTime.Parse(str, CultureInfo.InvariantCulture);
+ if (toType == typeof(Char))
+ {
+ char c = '\0';
+ Char.TryParse(str, out c);
+ return c;
+ }
+ if (toType == typeof(String) && str.StartsWith("{}", StringComparison.Ordinal))
+ return str.Substring(2);
+ if (toType == typeof(String))
+ return value;
+ if (toType == typeof(Decimal))
+ return Decimal.Parse(str, CultureInfo.InvariantCulture);
+ }
+
+ //if the value is not assignable and there's an implicit conversion, convert
+ if (value != null && !toType.IsAssignableFrom(value.GetType()))
+ {
+ var opImplicit = GetImplicitConversionOperator(value.GetType(), value.GetType(), toType)
+ ?? GetImplicitConversionOperator(toType, value.GetType(), toType);
+ //var opImplicit = value.GetType().GetImplicitConversionOperator(fromType: value.GetType(), toType: toType)
+ // ?? toType.GetImplicitConversionOperator(fromType: value.GetType(), toType: toType);
+
+ if (opImplicit != null)
+ {
+ value = opImplicit.Invoke(null, new[] { value });
+ return value;
+ }
+ }
+
+ var nativeValueConverterService = DependencyService.Get<INativeValueConverterService>();
+
+ object nativeValue = null;
+ if (nativeValueConverterService != null && nativeValueConverterService.ConvertTo(value, toType, out nativeValue))
+ return nativeValue;
+
+ return value;
+ }
+
+ internal string GetTypeConverterTypeName(IEnumerable<CustomAttributeData> attributes)
+ {
+ var converterAttribute =
+ attributes.FirstOrDefault(cad => TypeConverterAttribute.TypeConvertersType.Contains(cad.AttributeType.FullName));
+ if (converterAttribute == null)
+ return null;
+ if (converterAttribute.ConstructorArguments[0].ArgumentType == typeof(string))
+ return (string)converterAttribute.ConstructorArguments[0].Value;
+ if (converterAttribute.ConstructorArguments[0].ArgumentType == typeof(Type))
+ return ((Type)converterAttribute.ConstructorArguments[0].Value).AssemblyQualifiedName;
+ return null;
+ }
+
+ internal MethodInfo GetImplicitConversionOperator(Type onType, Type fromType, Type toType)
+ {
+#if NETSTANDARD1_0
+ var mi = onType.GetRuntimeMethod("op_Implicit", new[] { fromType });
+#else
+ var bindingFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy;
+ var mi = onType.GetMethod("op_Implicit", bindingFlags, null, new[] { fromType }, null);
+#endif
+ if (mi == null) return null;
+ if (!mi.IsSpecialName) return null;
+ if (!mi.IsPublic) return null;
+ if (!mi.IsStatic) return null;
+ if (!toType.IsAssignableFrom(mi.ReturnType)) return null;
+
+ return mi;
+ }
+
+
+ /// <summary>
+ /// Animates a property to a destination value.<br />
+ /// </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="startTime">The start time of the animation.</param>
+ /// <param name="endTime">The end time of the animation.</param>
+ /// <param name="alphaFunction">The alpha function to apply.</param>
+ /// <since_tizen> 3 </since_tizen>
+ public void AnimateTo(View target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
+ {
+ Property _prop = PropertyHelper.GetPropertyFromString(target, property);
PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
if(propertyType.Equals(PropertyType.Float))
/// <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>
+ /// <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 or 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>
+ /// <since_tizen> 3 </since_tizen>
public void AnimateBetween(View target, string property, KeyFrames keyFrames, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
{
- string _str1 = property.Substring(0, 1);
- string _str2 = property.Substring(1);
- string _str = _str1.ToLower() + _str2;
+ Property _prop = PropertyHelper.GetPropertyFromString(target, property);
- Property _prop = new Property(target, _str);
if (_prop.propertyIndex == Property.INVALID_INDEX)
{
throw new System.ArgumentException("second argument string property is invalid parameter!");
/// <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 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>
+ /// <param name="startTime">The start time of animation in milliseconds.</param>
+ /// <param name="endTime">The end time of animation in milliseconds.</param>
+ /// <param name="interpolation">The method used to interpolate between values.</param>
+ /// <param name="alphaFunction">The alpha function to apply.</param>
+ /// <since_tizen> 3 </since_tizen>
public void AnimateBetween(View target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
{
- string _str1 = property.Substring(0, 1);
- string _str2 = property.Substring(1);
- string _str = _str1.ToLower() + _str2;
-
- Property _prop = new Property(target, _str);
- if (_prop.propertyIndex == Property.INVALID_INDEX)
- {
- throw new System.ArgumentException("second argument string property is invalid parameter!");
- }
+ Property _prop = PropertyHelper.GetPropertyFromString(target, property);
Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
if (alphaFunction != null)
}
/// <summary>
- /// Animates an view's position and orientation through a predefined path.<br>
- /// The view will rotate to orient the supplied forward vector with the path's tangent.<br>
- /// If forward is the zero vector then no rotation will happen.<br>
+ /// Animates the view's position and orientation through a predefined path.<br />
+ /// The view will rotate to orient the supplied forward vector with the path's tangent.<br />
+ /// If forward is the zero vector then no rotation will happen.<br />
/// </summary>
- /// <param name="view">The view to animate</param>
- /// <param name="path">It defines position and orientation</param>
- /// <param name="forward">The vector (in local space coordinate system) that will be oriented with the path's tangent direction</param>
- /// <param name="alphaFunction">The alpha function to apply</param>
+ /// <param name="view">The view to animate.</param>
+ /// <param name="path">It defines position and orientation.</param>
+ /// <param name="forward">The vector (in local space coordinate system) will be oriented with the path's tangent direction.</param>
+ /// <param name="alphaFunction">The alpha function to apply.</param>
+ /// <since_tizen> 3 </since_tizen>
public void AnimatePath(View view, Path path, Vector3 forward, AlphaFunction alphaFunction = null)
{
if (alphaFunction == null)
}
/// <summary>
- /// Animates an view's position and orientation through a predefined path.<br>
- /// The view will rotate to orient the supplied forward vector with the path's tangent.<br>
- /// If forward is the zero vector then no rotation will happen.<br>
+ /// Animates the view's position and orientation through a predefined path.<br />
+ /// The view will rotate to orient the supplied forward vector with the path's tangent.<br />
+ /// If forward is the zero vector then no rotation will happen.<br />
/// </summary>
- /// <param name="view">The view to animate</param>
- /// <param name="path">It defines position and orientation</param>
- /// <param name="forward">The vector (in local space coordinate system) that will be oriented with the path's tangent direction</param>
- /// <param name="startTime">Start time of animation</param>
- /// <param name="endTime">End time of animation</param>
- /// <param name="alphaFunction">The alpha function to apply</param>
+ /// <param name="view">The view to animate.</param>
+ /// <param name="path">It defines position and orientation.</param>
+ /// <param name="forward">The vector (in local space coordinate system) will be oriented with the path's tangent direction.</param>
+ /// <param name="startTime">The start time of the animation.</param>
+ /// <param name="endTime">The end time of the animation.</param>
+ /// <param name="alphaFunction">The alpha function to apply.</param>
+ /// <since_tizen> 3 </since_tizen>
public void AnimatePath(View view, Path path, Vector3 forward, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
TimePeriod time = new TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
}
/// <summary>
- /// Creates an initialized Animation.<br>
- /// The animation will not loop.<br>
- /// The default end action is "Cancel".<br>
- /// The default alpha function is linear.<br>
+ /// Creates an initialized animation.<br />
+ /// The animation will not loop.<br />
+ /// The default end action is "Cancel".<br />
+ /// The default alpha function is linear.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public Animation() : this(NDalicPINVOKE.Animation_New(0.0f), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Downcasts a handle to Animation handle.<br>
- /// If handle points to an Animation object, the downcast produces valid handle.<br>
- /// If not, the returned handle is left uninitialized.<br>
+ /// Downcasts a handle to animation handle.<br />
+ /// If handle points to an animation object, the downcast produces a valid handle.<br />
+ /// If not, the returned handle is left uninitialized.<br />
/// </summary>
- /// <param name="handle">Handle to an object</param>
- /// <returns>Handle to an Animation object or an uninitialized handle</returns>
+ /// <param name="handle">Handle to an object.</param>
+ /// <returns>Handle to an animation object or an uninitialized handle.</returns>
+ /// <since_tizen> 3 </since_tizen>
public static Animation DownCast(BaseHandle handle)
{
Animation ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as Animation;
return ret;
}
+ private static bool? disableAnimation = null;
+ private bool DisableAnimation
+ {
+ get
+ {
+ if (disableAnimation.HasValue == false)
+ {
+ string type = Environment.GetEnvironmentVariable("PlatformSmartType");
+ if (type == "Entry")
+ disableAnimation = true;
+ else
+ disableAnimation = false;
+ }
+ return disableAnimation.Value;
+ }
+ }
+
/// <summary>
/// Plays the animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public void Play()
{
NDalicPINVOKE.Animation_Play(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-#if DISABLE_ANIMATION
- Stop(EndActions.StopFinal);
-#endif
+
+ if (DisableAnimation == true)
+ Stop(EndActions.StopFinal);
}
/// <summary>
- /// Plays the animation from a given point.<br>
+ /// Plays the animation from a given point.<br />
/// The progress must be in the 0-1 interval or in the play range interval if defined,
- /// otherwise, it will be ignored.<br>
+ /// otherwise, it will be ignored.<br />
/// </summary>
- /// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing</param>
+ /// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing.</param>
+ /// <since_tizen> 3 </since_tizen>
public void PlayFrom(float progress)
{
NDalicPINVOKE.Animation_PlayFrom(swigCPtr, progress);
}
/// <summary>
- /// Play the animation after a given delay time.<br/>
+ /// Plays the animation after a given delay time.<br/>
/// The delay time is not included in the looping time.<br/>
- /// When the delay time is negative value, it would treat as play immediately.<br/>
+ /// When the delay time is a negative value, it would treat as play immediately.<br/>
/// </summary>
- /// <param name="delayMiliSeconds">The delay time</param>
- public void PlayAfter(int delayMiliSeconds)
+ /// <param name="delayMilliseconds">The delay time.</param>
+ /// <since_tizen> 4 </since_tizen>
+ public void PlayAfter(int delayMilliseconds)
{
- NDalicPINVOKE.Animation_PlayAfter(swigCPtr, MilliSecondsToSeconds(delayMiliSeconds));
+ NDalicPINVOKE.Animation_PlayAfter(swigCPtr, MilliSecondsToSeconds(delayMilliseconds));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
/// Pauses the animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public void Pause()
{
NDalicPINVOKE.Animation_Pause(swigCPtr);
/// <summary>
/// Stops the animation.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public void Stop()
{
NDalicPINVOKE.Animation_Stop(swigCPtr);
}
/// <summary>
- /// Clears the animation.<br>
- /// This disconnects any objects that were being animated, effectively stopping the animation.<br>
+ /// Clears the animation.<br />
+ /// This disconnects any objects that were being animated, effectively stopping the animation.<br />
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public void Clear()
{
NDalicPINVOKE.Animation_Clear(swigCPtr);
}
/// <summary>
- /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.
+ /// Enumeration for what to do when the animation ends, stopped, or destroyed.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public enum EndActions
{
/// <summary>
/// </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.
+ /// 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.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public enum Interpolation
{
/// <summary>
/// <summary>
/// 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>
+ /// <remarks>Calling Reset() on this class will not reset the animation. It will call the BaseHandle.Reset() which drops the object handle.</remarks>
+ /// <since_tizen> 3 </since_tizen>
public enum States
{
/// <summary>
- /// Animation has stopped
+ /// The animation has stopped.
/// </summary>
Stopped,
/// <summary>
- /// The animation is playing
+ /// The animation is playing.
/// </summary>
Playing,
/// <summary>
- /// The animation is paused
+ /// The animation is paused.
/// </summary>
Paused
}