src/Tizen.NUI/src/public/Animation.cs

   1 /*
   2  * Copyright(c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 namespace Tizen.NUI
  19 {
  20     using System;
  21     using System.ComponentModel;
  22     using System.Runtime.InteropServices;
  23     using Tizen.NUI.BaseComponents;
  24
  25     using System.Collections;
  26     using System.Collections.Generic;
  27     using System.Linq;
  28     using System.Reflection;
  29     using System.Xml;
  30     using Tizen.NUI.Binding.Internals;
  31     using Tizen.NUI.Binding;
  32     using System.Globalization;
  33     using Tizen.NUI.Xaml.Internals;
  34
  35     /// <summary>
  36     /// Animation can be used to animate the properties of any number of objects, typically view.<br />
  37     /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.<br />
  38     /// This is typically done in the object destructor, and requires either the animation handle to be stored.<br />
  39     /// 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 />
  40     /// If any of the individual calls to those functions exceeds the overall animation time (Duration), then the overall animation time is automatically extended.<br />
  41     /// </summary>
  42     /// <since_tizen> 3 </since_tizen>
  43     public class Animation : BaseHandle
  44     {
  45         private static bool? disableAnimation = null;
  46
  47         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  48
  49         private AnimationFinishedEventCallbackType _animationFinishedEventCallback;
  50         private System.IntPtr _finishedCallbackOfNative;
  51
  52         private AnimationProgressReachedEventCallbackType _animationProgressReachedEventCallback;
  53
  54         private string[] _properties = null;
  55         private string[] _destValue = null;
  56         private int[] _startTime = null;
  57         private int[] _endTime = null;
  58
  59         /// <summary>
  60         /// Creates an initialized animation.<br />
  61         /// The animation will not loop.<br />
  62         /// The default end action is "Cancel".<br />
  63         /// The default alpha function is linear.<br />
  64         /// </summary>
  65         /// <remarks>DurationmSeconds must be greater than zero.</remarks>
  66         /// <param name="durationMilliSeconds">The duration in milliseconds.</param>
  67         /// <since_tizen> 3 </since_tizen>
  68         public Animation(int durationMilliSeconds) : this(Interop.Animation.Animation_New((float)durationMilliSeconds / 1000.0f), true)
  69         {
  70             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  71         }
  72
  73         internal Animation(global::System.IntPtr cPtr, bool cMemoryOwn) : base(Interop.Animation.Animation_SWIGUpcast(cPtr), cMemoryOwn)
  74         {
  75             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  76
  77             _animationFinishedEventCallback = OnFinished;
  78             _finishedCallbackOfNative = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(_animationFinishedEventCallback);
  79         }
  80
  81         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  82         private delegate void AnimationFinishedEventCallbackType(IntPtr data);
  83
  84         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  85         private delegate void AnimationProgressReachedEventCallbackType(IntPtr data);
  86
  87         private event EventHandler _animationFinishedEventHandler;
  88
  89         /**
  90         * @brief Event for the finished signal which can be used to subscribe or unsubscribe the event handler.
  91         * The finished signal is emitted when an animation's animations have finished.
  92         */
  93         /// <since_tizen> 3 </since_tizen>
  94         public event EventHandler Finished
  95         {
  96             add
  97             {
  98                 if (_animationFinishedEventHandler == null && disposed == false)
  99                 {
 100                     FinishedSignal().Connect(_finishedCallbackOfNative);
 101                 }
 102                 _animationFinishedEventHandler += value;
 103             }
 104             remove
 105             {
 106                 _animationFinishedEventHandler -= value;
 107
 108                 if (_animationFinishedEventHandler == null && FinishedSignal().Empty() == false)
 109                 {
 110                     FinishedSignal().Disconnect(_finishedCallbackOfNative);
 111                 }
 112             }
 113         }
 114
 115         private event EventHandler _animationProgressReachedEventHandler;
 116
 117         /**
 118        * @brief Event for the ProgressReached signal, which can be used to subscribe or unsubscribe the event handler.
 119        * The ProgressReached signal is emitted when the animation has reached a given progress percentage, this is set in the api SetProgressNotification.
 120        */
 121         /// <since_tizen> 3 </since_tizen>
 122         public event EventHandler ProgressReached
 123         {
 124             add
 125             {
 126                 if (_animationProgressReachedEventHandler == null)
 127                 {
 128                     _animationProgressReachedEventCallback = OnProgressReached;
 129                     ProgressReachedSignal().Connect(_animationProgressReachedEventCallback);
 130                 }
 131
 132                 _animationProgressReachedEventHandler += value;
 133             }
 134             remove
 135             {
 136                 _animationProgressReachedEventHandler -= value;
 137
 138                 if (_animationProgressReachedEventHandler == null && ProgressReachedSignal().Empty() == false)
 139                 {
 140                     ProgressReachedSignal().Disconnect(_animationProgressReachedEventCallback);
 141                 }
 142             }
 143         }
 144
 145         /// <summary>
 146         /// Enumeration for what to do when the animation ends, stopped, or destroyed.
 147         /// </summary>
 148         /// <since_tizen> 3 </since_tizen>
 149         public enum EndActions
 150         {
 151             /// <summary>
 152             /// When the animation ends, the animated property values are saved.
 153             /// </summary>
 154             Cancel,
 155             /// <summary>
 156             /// When the animation ends, the animated property values are forgotten.
 157             /// </summary>
 158             Discard,
 159             /// <summary>
 160             /// If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like cancel.
 161             /// </summary>
 162             StopFinal
 163         }
 164
 165         /// <summary>
 166         /// Enumeration for what interpolation method to use on key-frame animations.
 167         /// </summary>
 168         /// <since_tizen> 3 </since_tizen>
 169         public enum Interpolation
 170         {
 171             /// <summary>
 172             /// Values in between key frames are interpolated using a linear polynomial. (Default)
 173             /// </summary>
 174             Linear,
 175             /// <summary>
 176             /// Values in between key frames are interpolated using a cubic polynomial.
 177             /// </summary>
 178             Cubic
 179         }
 180
 181         /// <summary>
 182         /// Enumeration for what state the animation is in.
 183         /// </summary>
 184         /// <remarks>Calling Reset() on this class will not reset the animation. It will call the BaseHandle.Reset() which drops the object handle.</remarks>
 185         /// <since_tizen> 3 </since_tizen>
 186         public enum States
 187         {
 188             /// <summary>
 189             /// The animation has stopped.
 190             /// </summary>
 191             Stopped,
 192             /// <summary>
 193             /// The animation is playing.
 194             /// </summary>
 195             Playing,
 196             /// <summary>
 197             /// The animation is paused.
 198             /// </summary>
 199             Paused
 200         }
 201
 202         /// <summary>
 203         /// Gets or sets the duration in milliseconds of the animation.
 204         /// </summary>
 205         /// <since_tizen> 3 </since_tizen>
 206         public int Duration
 207         {
 208             set
 209             {
 210                 SetDuration(MilliSecondsToSeconds(value));
 211             }
 212             get
 213             {
 214                 return SecondsToMilliSeconds(GetDuration());
 215             }
 216         }
 217
 218         /// <summary>
 219         ///  Gets or sets the default alpha function for the animation.
 220         /// </summary>
 221         /// <since_tizen> 3 </since_tizen>
 222         public AlphaFunction DefaultAlphaFunction
 223         {
 224             set
 225             {
 226                 SetDefaultAlphaFunction(value);
 227             }
 228             get
 229             {
 230                 AlphaFunction ret = GetDefaultAlphaFunction();
 231                 return ret;
 232             }
 233         }
 234
 235         /// <summary>
 236         /// Queries the state of the animation.
 237         /// </summary>
 238         /// <since_tizen> 3 </since_tizen>
 239         public States State
 240         {
 241             get
 242             {
 243                 return GetState();
 244             }
 245         }
 246
 247         /// <summary>
 248         /// Set: Enables looping for a specified number of repeats. A zero is the same as Looping = true; i.e., repeat forever.<br />
 249         /// This property resets the looping value and should not be used with the Looping property.<br />
 250         /// Setting this parameter does not cause the animation to Play().<br />
 251         /// Get: Gets the loop count. A zero is the same as Looping = true; i.e., repeat forever.<br />
 252         /// The loop count is initially 1 for play once.<br />
 253         /// </summary>
 254         /// <since_tizen> 3 </since_tizen>
 255         public int LoopCount
 256         {
 257             set
 258             {
 259                 SetLoopCount(value);
 260             }
 261             get
 262             {
 263                 int ret = GetLoopCount();
 264                 return ret;
 265             }
 266         }
 267
 268         /// <summary>
 269         /// Gets or sets the status of whether the animation will loop.<br />
 270         /// This property resets the loop count and should not be used with the LoopCount property.<br />
 271         /// Setting this parameter does not cause the animation to Play().<br />
 272         /// </summary>
 273         /// <since_tizen> 3 </since_tizen>
 274         public bool Looping
 275         {
 276             set
 277             {
 278                 SetLooping(value);
 279             }
 280             get
 281             {
 282                 bool ret = IsLooping();
 283                 return ret;
 284             }
 285         }
 286
 287
 288         /// <summary>
 289         /// Gets or sets the end action of the animation.<br />
 290         /// This action is performed when the animation ends or if it is stopped.<br />
 291         /// The default end action is cancel.<br />
 292         /// </summary>
 293         /// <since_tizen> 3 </since_tizen>
 294         public EndActions EndAction
 295         {
 296             set
 297             {
 298                 SetEndAction(value);
 299             }
 300             get
 301             {
 302                 return GetEndAction();
 303             }
 304         }
 305
 306         /// <summary>
 307         /// Gets the current loop count.<br />
 308         /// A value 0 indicating the current loop count when looping.<br />
 309         /// </summary>
 310         /// <since_tizen> 3 </since_tizen>
 311         public int CurrentLoop
 312         {
 313             get
 314             {
 315                 return GetCurrentLoop();
 316             }
 317         }
 318
 319         /// <summary>
 320         /// Gets or sets the disconnect action.<br />
 321         /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.<br />
 322         /// The default action is cancel.<br />
 323         /// </summary>
 324         /// <since_tizen> 3 </since_tizen>
 325         public EndActions DisconnectAction
 326         {
 327             set
 328             {
 329                 Interop.Animation.Animation_SetDisconnectAction(swigCPtr, (int)value);
 330                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 331             }
 332             get
 333             {
 334                 Animation.EndActions ret = (Animation.EndActions)Interop.Animation.Animation_GetDisconnectAction(swigCPtr);
 335                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 336                 return ret;
 337             }
 338         }
 339
 340
 341         /// <summary>
 342         /// Gets or sets the progress of the animation.<br />
 343         /// The animation will play (or continue playing) from this point.<br />
 344         /// The progress must be in the 0-1 interval or in the play range interval if defined<br />
 345         /// otherwise, it will be ignored.<br />
 346         /// </summary>
 347         /// <since_tizen> 3 </since_tizen>
 348         public float CurrentProgress
 349         {
 350             set
 351             {
 352                 Interop.Animation.Animation_SetCurrentProgress(swigCPtr, value);
 353                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 354             }
 355             get
 356             {
 357                 float ret = Interop.Animation.Animation_GetCurrentProgress(swigCPtr);
 358                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 359                 return ret;
 360             }
 361         }
 362
 363         /// <summary>
 364         /// Gets or sets specificifications of a speed factor for the animation.<br />
 365         /// The speed factor is a multiplier of the normal velocity of the animation.<br />
 366         /// Values between [0, 1] will slow down the animation and values above one will speed up the animation.<br />
 367         /// It is also possible to specify a negative multiplier to play the animation in reverse.<br />
 368         /// </summary>
 369         /// <since_tizen> 3 </since_tizen>
 370         public float SpeedFactor
 371         {
 372             set
 373             {
 374                 Interop.Animation.Animation_SetSpeedFactor(swigCPtr, value);
 375                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376             }
 377             get
 378             {
 379                 float ret = Interop.Animation.Animation_GetSpeedFactor(swigCPtr);
 380                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 381                 return ret;
 382             }
 383         }
 384
 385         /// <summary>
 386         /// Gets or sets the playing range.<br />
 387         /// Animation will play between the values specified. Both values (range.x and range.y ) should be between 0-1,
 388         /// otherwise they will be ignored. If the range provided is not in proper order (minimum, maximum ), it will be reordered.<br />
 389         /// </summary>
 390         /// <since_tizen> 3 </since_tizen>
 391         public RelativeVector2 PlayRange
 392         {
 393             set
 394             {
 395                 Interop.Animation.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(value));
 396                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 397             }
 398             get
 399             {
 400                 Vector2 ret = new Vector2(Interop.Animation.Animation_GetPlayRange(swigCPtr), true);
 401                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 402                 return ret;
 403             }
 404         }
 405
 406
 407         /// <summary>
 408         /// Gets or sets the progress notification marker which triggers the ProgressReachedSignal.<br />
 409         /// Percentage of animation progress should be greater than 0 and less than 1, for example, 0.3 for 30% <br />
 410         /// One notification can be set on each animation.
 411         /// </summary>
 412         /// <since_tizen> 3 </since_tizen>
 413         public float ProgressNotification
 414         {
 415             set
 416             {
 417                 Interop.Animation.Animation_SetProgressNotification(swigCPtr, value);
 418                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 419             }
 420             get
 421             {
 422                 float ret = Interop.Animation.Animation_GetProgressNotification(swigCPtr);
 423                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 424                 return ret;
 425             }
 426         }
 427
 428         /// <summary>
 429         /// Gets or sets the properties of the animation.
 430         /// </summary>
 431         public string[] Properties
 432         {
 433             get
 434             {
 435                 return _properties;
 436             }
 437             set
 438             {
 439                 _properties = value;
 440             }
 441         }
 442
 443         /// <summary>
 444         /// Gets or sets the destination value for each property of the animation.
 445         /// </summary>
 446         public string[] DestValue
 447         {
 448             get
 449             {
 450                 return _destValue;
 451             }
 452             set
 453             {
 454                 _destValue = value;
 455             }
 456         }
 457
 458         /// <summary>
 459         /// Gets or sets the start time for each property of the animation.
 460         /// </summary>
 461         public int[] StartTime
 462         {
 463             get
 464             {
 465                 return _startTime;
 466             }
 467             set
 468             {
 469                 _startTime = value;
 470             }
 471         }
 472
 473         /// <summary>
 474         /// Gets or sets the end time for each property of the animation.
 475         /// </summary>
 476         public int[] EndTime
 477         {
 478             get
 479             {
 480                 return _endTime;
 481             }
 482             set
 483             {
 484                 _endTime = value;
 485             }
 486         }
 487
 488         private bool DisableAnimation
 489         {
 490             get
 491             {
 492                 if (disableAnimation.HasValue == false)
 493                 {
 494                     string type = Environment.GetEnvironmentVariable("PlatformSmartType");
 495                     if (type == "Entry")
 496                         disableAnimation = true;
 497                     else
 498                         disableAnimation = false;
 499                 }
 500                 return disableAnimation.Value;
 501             }
 502         }
 503
 504         /// <summary>
 505         /// Downcasts a handle to animation handle.<br />
 506         /// If handle points to an animation object, the downcast produces a valid handle.<br />
 507         /// If not, the returned handle is left uninitialized.<br />
 508         /// </summary>
 509         /// <param name="handle">Handle to an object.</param>
 510         /// <returns>Handle to an animation object or an uninitialized handle.</returns>
 511         /// <since_tizen> 3 </since_tizen>
 512         [Obsolete("Deprecated in API6, Will be removed in API9, Please use as keyword instead!")]
 513         [EditorBrowsable(EditorBrowsableState.Never)]
 514         public static Animation DownCast(BaseHandle handle)
 515         {
 516             Animation ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as Animation;
 517             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 518             return ret;
 519         }
 520
 521         /// <summary>
 522         /// Stops the animation.
 523         /// </summary>
 524         /// <param name="action">The end action can be set.</param>
 525         /// <since_tizen> 3 </since_tizen>
 526         public void Stop(EndActions action = EndActions.Cancel)
 527         {
 528             SetEndAction(action);
 529             Interop.Animation.Animation_Stop(swigCPtr);
 530             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 531         }
 532
 533         /// <summary>
 534         /// Animates a property value by a relative amount.<br />
 535         /// </summary>
 536         /// <param name="target">The target object to animate.</param>
 537         /// <param name="property">The target property to animate.</param>
 538         /// <param name="relativeValue">The property value will change by this amount.</param>
 539         /// <param name="alphaFunction">The alpha function to apply.</param>
 540         /// <since_tizen> 3 </since_tizen>
 541         public void AnimateBy(View target, string property, object relativeValue, AlphaFunction alphaFunction = null)
 542         {
 543             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 544             relativeValue = AvoidFloatPropertyHasIntegerValue(target, _prop, relativeValue);
 545             PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
 546
 547             if (alphaFunction != null)
 548             {
 549                 AnimateBy(_prop, val, alphaFunction);
 550             }
 551             else
 552             {
 553                 AnimateBy(_prop, val);
 554             }
 555         }
 556
 557         /// <summary>
 558         /// Animates a property value by a relative amount.<br />
 559         /// </summary>
 560         /// <param name="target">The target object to animate.</param>
 561         /// <param name="property">The target property to animate.</param>
 562         /// <param name="relativeValue">The property value will change by this amount.</param>
 563         /// <param name="startTime">The start time of the animation.</param>
 564         /// <param name="endTime">The end time of the animation.</param>
 565         /// <param name="alphaFunction">The alpha function to apply.</param>
 566         /// <since_tizen> 3 </since_tizen>
 567         public void AnimateBy(View target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
 568         {
 569             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 570             relativeValue = AvoidFloatPropertyHasIntegerValue(target, _prop, relativeValue);
 571             PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
 572
 573             if (alphaFunction != null)
 574             {
 575                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 576                 AnimateBy(_prop, val, alphaFunction, time);
 577             }
 578             else
 579             {
 580                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 581                 AnimateBy(_prop, val, time);
 582             }
 583         }
 584
 585         /// <summary>
 586         /// Animates a property to a destination value.<br />
 587         /// </summary>
 588         /// <param name="target">The target object to animate.</param>
 589         /// <param name="property">The target property to animate.</param>
 590         /// <param name="destinationValue">The destination value.</param>
 591         /// <param name="alphaFunction">The alpha function to apply.</param>
 592         /// <since_tizen> 3 </since_tizen>
 593         public void AnimateTo(View target, string property, object destinationValue, AlphaFunction alphaFunction = null)
 594         {
 595             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 596             destinationValue = AvoidFloatPropertyHasIntegerValue(target, _prop, destinationValue);
 597             PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 598
 599             if (alphaFunction != null)
 600             {
 601                 AnimateTo(_prop, val, alphaFunction);
 602             }
 603             else
 604             {
 605                 AnimateTo(_prop, val);
 606             }
 607         }
 608
 609         /// <summary>
 610         /// Animates one or more properties to a destination value.<br />
 611         /// </summary>
 612         /// <param name="target">The target object to animate.</param>
 613         public void PlayAnimateTo(View target)
 614         {
 615             Clear();
 616             if (_properties.Length == _destValue.Length && _startTime.Length == _endTime.Length && _properties.Length == _startTime.Length)
 617             {
 618                 int length = _properties.Length;
 619                 for (int index = 0; index < length; index++)
 620                 {
 621                     //object destinationValue = _destValue[index];
 622                     var elementType = target.GetType();
 623                     PropertyInfo propertyInfo = elementType.GetProperties().FirstOrDefault(fi => fi.Name == _properties[index]);
 624                     //var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localName);
 625                     if (propertyInfo != null)
 626                     {
 627                         object destinationValue = ConvertTo(_destValue[index], propertyInfo.PropertyType);
 628
 629                         if (destinationValue != null)
 630                         {
 631                             AnimateTo(target, _properties[index], destinationValue, _startTime[index], _endTime[index]);
 632                         }
 633                     }
 634                 }
 635                 Play();
 636             }
 637         }
 638
 639         /// <summary>
 640         /// Animates a property to a destination value.<br />
 641         /// </summary>
 642         /// <param name="target">The target object to animate.</param>
 643         /// <param name="property">The target property to animate.</param>
 644         /// <param name="destinationValue">The destination value.</param>
 645         /// <param name="startTime">The start time of the animation.</param>
 646         /// <param name="endTime">The end time of the animation.</param>
 647         /// <param name="alphaFunction">The alpha function to apply.</param>
 648         /// <since_tizen> 3 </since_tizen>
 649         public void AnimateTo(View target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
 650         {
 651             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 652             destinationValue = AvoidFloatPropertyHasIntegerValue(target, _prop, destinationValue);
 653             PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 654
 655             if (alphaFunction != null)
 656             {
 657                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 658                 AnimateTo(_prop, val, alphaFunction, time);
 659             }
 660             else
 661             {
 662                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 663                 AnimateTo(_prop, val, time);
 664             }
 665         }
 666
 667         /// <summary>
 668         /// Animates a property between keyframes.
 669         /// </summary>
 670         /// <param name="target">The target object to animate.</param>
 671         /// <param name="property">The target property to animate.</param>
 672         /// <param name="keyFrames">The set of time or value pairs between which to animate.</param>
 673         /// <param name="interpolation">The method used to interpolate between values.</param>
 674         /// <param name="alphaFunction">The alpha function to apply.</param>
 675         /// <since_tizen> 3 </since_tizen>
 676         public void AnimateBetween(View target, string property, KeyFrames keyFrames, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
 677         {
 678             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 679
 680             if (_prop.propertyIndex == Property.INVALID_INDEX)
 681             {
 682                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 683             }
 684
 685             if (alphaFunction != null)
 686             {
 687                 AnimateBetween(_prop, keyFrames, alphaFunction, interpolation);
 688             }
 689             else
 690             {
 691                 AnimateBetween(_prop, keyFrames, interpolation);
 692             }
 693         }
 694
 695         /// <summary>
 696         /// Animates a property between keyframes.
 697         /// </summary>
 698         /// <param name="target">The target object to animate</param>
 699         /// <param name="property">The target property to animate</param>
 700         /// <param name="keyFrames">The set of time/value pairs between which to animate</param>
 701         /// <param name="startTime">The start time of animation in milliseconds.</param>
 702         /// <param name="endTime">The end time of animation in milliseconds.</param>
 703         /// <param name="interpolation">The method used to interpolate between values.</param>
 704         /// <param name="alphaFunction">The alpha function to apply.</param>
 705         /// <since_tizen> 3 </since_tizen>
 706         public void AnimateBetween(View target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
 707         {
 708             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 709
 710             Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 711             if (alphaFunction != null)
 712             {
 713                 AnimateBetween(_prop, keyFrames, alphaFunction, time, interpolation);
 714             }
 715             else
 716             {
 717                 AnimateBetween(_prop, keyFrames, time, interpolation);
 718             }
 719         }
 720
 721         /// <summary>
 722         /// Animates the view's position and orientation through a predefined path.<br />
 723         /// The view will rotate to orient the supplied forward vector with the path's tangent.<br />
 724         /// If forward is the zero vector then no rotation will happen.<br />
 725         /// </summary>
 726         /// <param name="view">The view to animate.</param>
 727         /// <param name="path">It defines position and orientation.</param>
 728         /// <param name="forward">The vector (in local space coordinate system) will be oriented with the path's tangent direction.</param>
 729         /// <param name="alphaFunction">The alpha function to apply.</param>
 730         /// <since_tizen> 3 </since_tizen>
 731         public void AnimatePath(View view, Path path, Vector3 forward, AlphaFunction alphaFunction = null)
 732         {
 733             if (alphaFunction == null)
 734             {
 735                 Animate(view, path, forward);
 736             }
 737             else
 738             {
 739                 Animate(view, path, forward, alphaFunction);
 740             }
 741         }
 742
 743         /// <summary>
 744         /// Animates the view's position and orientation through a predefined path.<br />
 745         /// The view will rotate to orient the supplied forward vector with the path's tangent.<br />
 746         /// If forward is the zero vector then no rotation will happen.<br />
 747         /// </summary>
 748         /// <param name="view">The view to animate.</param>
 749         /// <param name="path">It defines position and orientation.</param>
 750         /// <param name="forward">The vector (in local space coordinate system) will be oriented with the path's tangent direction.</param>
 751         /// <param name="startTime">The start time of the animation.</param>
 752         /// <param name="endTime">The end time of the animation.</param>
 753         /// <param name="alphaFunction">The alpha function to apply.</param>
 754         /// <since_tizen> 3 </since_tizen>
 755         public void AnimatePath(View view, Path path, Vector3 forward, int startTime, int endTime, AlphaFunction alphaFunction = null)
 756         {
 757             TimePeriod time = new TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 758             if (alphaFunction == null)
 759             {
 760                 Animate(view, path, forward, time);
 761             }
 762             else
 763             {
 764                 Animate(view, path, forward, alphaFunction, time);
 765             }
 766         }
 767
 768         /// <summary>
 769         /// Creates an initialized animation.<br />
 770         /// The animation will not loop.<br />
 771         /// The default end action is "Cancel".<br />
 772         /// The default alpha function is linear.<br />
 773         /// </summary>
 774         /// <since_tizen> 3 </since_tizen>
 775         public Animation() : this(Interop.Animation.Animation_New(0.0f), true)
 776         {
 777             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 778         }
 779
 780         /// <summary>
 781         /// Plays the animation.
 782         /// </summary>
 783         /// <since_tizen> 3 </since_tizen>
 784         public void Play()
 785         {
 786             Interop.Animation.Animation_Play(swigCPtr);
 787             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 788
 789             if (DisableAnimation == true)
 790                 Stop(EndActions.StopFinal);
 791         }
 792
 793         /// <summary>
 794         /// Plays the animation from a given point.<br />
 795         /// The progress must be in the 0-1 interval or in the play range interval if defined,
 796         /// otherwise, it will be ignored.<br />
 797         /// </summary>
 798         /// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing.</param>
 799         /// <since_tizen> 3 </since_tizen>
 800         public void PlayFrom(float progress)
 801         {
 802             Interop.Animation.Animation_PlayFrom(swigCPtr, progress);
 803             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 804         }
 805
 806         /// <summary>
 807         /// Plays the animation after a given delay time.<br/>
 808         /// The delay time is not included in the looping time.<br/>
 809         /// When the delay time is a negative value, it would treat as play immediately.<br/>
 810         /// </summary>
 811         /// <param name="delayMilliseconds">The delay time.</param>
 812         /// <since_tizen> 4 </since_tizen>
 813         public void PlayAfter(int delayMilliseconds)
 814         {
 815             Interop.Animation.Animation_PlayAfter(swigCPtr, MilliSecondsToSeconds(delayMilliseconds));
 816             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 817         }
 818
 819         /// <summary>
 820         /// Pauses the animation.
 821         /// </summary>
 822         /// <since_tizen> 3 </since_tizen>
 823         public void Pause()
 824         {
 825             Interop.Animation.Animation_Pause(swigCPtr);
 826             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 827         }
 828
 829         /// <summary>
 830         /// Stops the animation.
 831         /// </summary>
 832         /// <since_tizen> 3 </since_tizen>
 833         public void Stop()
 834         {
 835             Interop.Animation.Animation_Stop(swigCPtr);
 836             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 837         }
 838
 839         /// <summary>
 840         /// Clears the animation.<br />
 841         /// This disconnects any objects that were being animated, effectively stopping the animation.<br />
 842         /// </summary>
 843         /// <since_tizen> 3 </since_tizen>
 844         public void Clear()
 845         {
 846             Interop.Animation.Animation_Clear(swigCPtr);
 847             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 848         }
 849
 850         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animation obj)
 851         {
 852             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 853         }
 854
 855         internal object ConvertTo(object value, Type toType)
 856         {
 857             Func<object> getConverter = () =>
 858             {
 859                 string converterTypeName = GetTypeConverterTypeName(toType.GetTypeInfo().CustomAttributes);
 860                 if (converterTypeName == null)
 861                     return null;
 862
 863                 Type convertertype = Type.GetType(converterTypeName);
 864                 return Activator.CreateInstance(convertertype);
 865             };
 866
 867             return ConvertTo(value, toType, getConverter);
 868         }
 869
 870         internal object ConvertTo(object value, Type toType, Func<object> getConverter)
 871         {
 872             if (value == null)
 873                 return null;
 874
 875             var str = value as string;
 876             if (str != null)
 877             {
 878                 //If there's a [TypeConverter], use it
 879                 object converter = getConverter?.Invoke();
 880                 var xfTypeConverter = converter as Tizen.NUI.Binding.TypeConverter;
 881                 if (xfTypeConverter != null)
 882                     return value = xfTypeConverter.ConvertFromInvariantString(str);
 883                 var converterType = converter?.GetType();
 884                 if (converterType != null)
 885                 {
 886                     var convertFromStringInvariant = converterType.GetRuntimeMethod("ConvertFromInvariantString",
 887                         new[] { typeof(string) });
 888                     if (convertFromStringInvariant != null)
 889                         return value = convertFromStringInvariant.Invoke(converter, new object[] { str });
 890                 }
 891
 892                 //If the type is nullable, as the value is not null, it's safe to assume we want the built-in conversion
 893                 if (toType.GetTypeInfo().IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>))
 894                     toType = Nullable.GetUnderlyingType(toType);
 895
 896                 //Obvious Built-in conversions
 897                 if (toType.GetTypeInfo().IsEnum)
 898                     return Enum.Parse(toType, str, true);
 899                 if (toType == typeof(SByte))
 900                     return SByte.Parse(str, CultureInfo.InvariantCulture);
 901                 if (toType == typeof(Int16))
 902                     return Int16.Parse(str, CultureInfo.InvariantCulture);
 903                 if (toType == typeof(Int32))
 904                     return Int32.Parse(str, CultureInfo.InvariantCulture);
 905                 if (toType == typeof(Int64))
 906                     return Int64.Parse(str, CultureInfo.InvariantCulture);
 907                 if (toType == typeof(Byte))
 908                     return Byte.Parse(str, CultureInfo.InvariantCulture);
 909                 if (toType == typeof(UInt16))
 910                     return UInt16.Parse(str, CultureInfo.InvariantCulture);
 911                 if (toType == typeof(UInt32))
 912                     return UInt32.Parse(str, CultureInfo.InvariantCulture);
 913                 if (toType == typeof(UInt64))
 914                     return UInt64.Parse(str, CultureInfo.InvariantCulture);
 915                 if (toType == typeof(Single))
 916                     return Single.Parse(str, CultureInfo.InvariantCulture);
 917                 if (toType == typeof(Double))
 918                     return Double.Parse(str, CultureInfo.InvariantCulture);
 919                 if (toType == typeof(Boolean))
 920                     return Boolean.Parse(str);
 921                 if (toType == typeof(TimeSpan))
 922                     return TimeSpan.Parse(str, CultureInfo.InvariantCulture);
 923                 if (toType == typeof(DateTime))
 924                     return DateTime.Parse(str, CultureInfo.InvariantCulture);
 925                 if (toType == typeof(Char))
 926                 {
 927                     char c = '\0';
 928                     Char.TryParse(str, out c);
 929                     return c;
 930                 }
 931                 if (toType == typeof(String) && str.StartsWith("{}", StringComparison.Ordinal))
 932                     return str.Substring(2);
 933                 if (toType == typeof(String))
 934                     return value;
 935                 if (toType == typeof(Decimal))
 936                     return Decimal.Parse(str, CultureInfo.InvariantCulture);
 937             }
 938
 939             //if the value is not assignable and there's an implicit conversion, convert
 940             if (value != null && !toType.IsAssignableFrom(value.GetType()))
 941             {
 942                 var opImplicit = GetImplicitConversionOperator(value.GetType(), value.GetType(), toType)
 943                                  ?? GetImplicitConversionOperator(toType, value.GetType(), toType);
 944                 //var opImplicit = value.GetType().GetImplicitConversionOperator(fromType: value.GetType(), toType: toType)
 945                 //                ?? toType.GetImplicitConversionOperator(fromType: value.GetType(), toType: toType);
 946
 947                 if (opImplicit != null)
 948                 {
 949                     value = opImplicit.Invoke(null, new[] { value });
 950                     return value;
 951                 }
 952             }
 953
 954             return value;
 955         }
 956
 957         internal string GetTypeConverterTypeName(IEnumerable<CustomAttributeData> attributes)
 958         {
 959             var converterAttribute =
 960                 attributes.FirstOrDefault(cad => Tizen.NUI.Binding.TypeConverterAttribute.TypeConvertersType.Contains(cad.AttributeType.FullName));
 961             if (converterAttribute == null)
 962                 return null;
 963             if (converterAttribute.ConstructorArguments[0].ArgumentType == typeof(string))
 964                 return (string)converterAttribute.ConstructorArguments[0].Value;
 965             if (converterAttribute.ConstructorArguments[0].ArgumentType == typeof(Type))
 966                 return ((Type)converterAttribute.ConstructorArguments[0].Value).AssemblyQualifiedName;
 967             return null;
 968         }
 969
 970         internal MethodInfo GetImplicitConversionOperator(Type onType, Type fromType, Type toType)
 971         {
 972 #if NETSTANDARD1_0
 973             var mi = onType.GetRuntimeMethod("op_Implicit", new[] { fromType });
 974 #else
 975             var bindingFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy;
 976             var mi = onType.GetMethod("op_Implicit", bindingFlags, null, new[] { fromType }, null);
 977 #endif
 978             if (mi == null) return null;
 979             if (!mi.IsSpecialName) return null;
 980             if (!mi.IsPublic) return null;
 981             if (!mi.IsStatic) return null;
 982             if (!toType.IsAssignableFrom(mi.ReturnType)) return null;
 983
 984             return mi;
 985         }
 986
 987         internal Animation(float durationSeconds) : this(Interop.Animation.Animation_New(durationSeconds), true)
 988         {
 989             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 990
 991         }
 992
 993         internal Animation(Animation handle) : this(Interop.Animation.new_Animation__SWIG_1(Animation.getCPtr(handle)), true)
 994         {
 995             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 996         }
 997
 998         internal Animation Assign(Animation rhs)
 999         {
1000             Animation ret = new Animation(Interop.Animation.Animation_Assign(swigCPtr, Animation.getCPtr(rhs)), false);
1001             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1002             return ret;
1003         }
1004
1005         internal void SetDuration(float seconds)
1006         {
1007             Interop.Animation.Animation_SetDuration(swigCPtr, seconds);
1008             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1009         }
1010
1011         internal float GetDuration()
1012         {
1013             float ret = Interop.Animation.Animation_GetDuration(swigCPtr);
1014             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1015             return ret;
1016         }
1017
1018         internal void SetLooping(bool looping)
1019         {
1020             Interop.Animation.Animation_SetLooping(swigCPtr, looping);
1021             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1022         }
1023
1024         internal void SetLoopCount(int count)
1025         {
1026             Interop.Animation.Animation_SetLoopCount(swigCPtr, count);
1027             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1028         }
1029
1030         internal int GetLoopCount()
1031         {
1032             int ret = Interop.Animation.Animation_GetLoopCount(swigCPtr);
1033             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1034             return ret;
1035         }
1036
1037         internal int GetCurrentLoop()
1038         {
1039             int ret = Interop.Animation.Animation_GetCurrentLoop(swigCPtr);
1040             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1041             return ret;
1042         }
1043
1044         internal bool IsLooping()
1045         {
1046             bool ret = Interop.Animation.Animation_IsLooping(swigCPtr);
1047             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1048             return ret;
1049         }
1050
1051         internal void SetEndAction(Animation.EndActions action)
1052         {
1053             Interop.Animation.Animation_SetEndAction(swigCPtr, (int)action);
1054             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1055         }
1056
1057         internal Animation.EndActions GetEndAction()
1058         {
1059             Animation.EndActions ret = (Animation.EndActions)Interop.Animation.Animation_GetEndAction(swigCPtr);
1060             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1061             return ret;
1062         }
1063
1064         internal void SetDisconnectAction(Animation.EndActions disconnectAction)
1065         {
1066             Interop.Animation.Animation_SetDisconnectAction(swigCPtr, (int)disconnectAction);
1067             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1068         }
1069
1070         internal Animation.EndActions GetDisconnectAction()
1071         {
1072             Animation.EndActions ret = (Animation.EndActions)Interop.Animation.Animation_GetDisconnectAction(swigCPtr);
1073             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1074             return ret;
1075         }
1076
1077         internal void SetDefaultAlphaFunction(AlphaFunction alpha)
1078         {
1079             Interop.Animation.Animation_SetDefaultAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
1080             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1081         }
1082
1083         internal AlphaFunction GetDefaultAlphaFunction()
1084         {
1085             AlphaFunction ret = new AlphaFunction(Interop.Animation.Animation_GetDefaultAlphaFunction(swigCPtr), true);
1086             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1087             return ret;
1088         }
1089
1090         internal void SetCurrentProgress(float progress)
1091         {
1092             Interop.Animation.Animation_SetCurrentProgress(swigCPtr, progress);
1093             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1094         }
1095
1096         internal float GetCurrentProgress()
1097         {
1098             float ret = Interop.Animation.Animation_GetCurrentProgress(swigCPtr);
1099             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1100             return ret;
1101         }
1102
1103         internal void SetSpeedFactor(float factor)
1104         {
1105             Interop.Animation.Animation_SetSpeedFactor(swigCPtr, factor);
1106             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1107         }
1108
1109         internal float GetSpeedFactor()
1110         {
1111             float ret = Interop.Animation.Animation_GetSpeedFactor(swigCPtr);
1112             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1113             return ret;
1114         }
1115
1116         internal void SetPlayRange(Vector2 range)
1117         {
1118             Interop.Animation.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(range));
1119             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1120         }
1121
1122         internal Vector2 GetPlayRange()
1123         {
1124             Vector2 ret = new Vector2(Interop.Animation.Animation_GetPlayRange(swigCPtr), true);
1125             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1126             return ret;
1127         }
1128
1129         internal Animation.States GetState()
1130         {
1131             Animation.States ret = (Animation.States)Interop.Animation.Animation_GetState(swigCPtr);
1132             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1133             return ret;
1134         }
1135
1136         internal AnimationSignal FinishedSignal()
1137         {
1138             AnimationSignal ret = new AnimationSignal(Interop.Animation.Animation_FinishedSignal(swigCPtr), false);
1139             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1140             return ret;
1141         }
1142
1143         internal AnimationSignal ProgressReachedSignal()
1144         {
1145             AnimationSignal ret = new AnimationSignal(Interop.Animation.Animation_ProgressReachedSignal(swigCPtr), false);
1146             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1147             return ret;
1148         }
1149
1150         internal void AnimateBy(Property target, PropertyValue relativeValue)
1151         {
1152             Interop.Animation.Animation_AnimateBy__SWIG_0(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue));
1153             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1154         }
1155
1156         internal void AnimateBy(Property target, PropertyValue relativeValue, AlphaFunction alpha)
1157         {
1158             Interop.Animation.Animation_AnimateBy__SWIG_1(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha));
1159             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1160         }
1161
1162         internal void AnimateBy(Property target, PropertyValue relativeValue, TimePeriod period)
1163         {
1164             Interop.Animation.Animation_AnimateBy__SWIG_2(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), TimePeriod.getCPtr(period));
1165             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1166         }
1167
1168         internal void AnimateBy(Property target, PropertyValue relativeValue, AlphaFunction alpha, TimePeriod period)
1169         {
1170             Interop.Animation.Animation_AnimateBy__SWIG_3(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1171             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1172         }
1173
1174         internal void AnimateTo(Property target, PropertyValue destinationValue)
1175         {
1176             Interop.Animation.Animation_AnimateTo__SWIG_0(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue));
1177             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1178         }
1179
1180         internal void AnimateTo(Property target, PropertyValue destinationValue, AlphaFunction alpha)
1181         {
1182             Interop.Animation.Animation_AnimateTo__SWIG_1(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha));
1183             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1184         }
1185
1186         internal void AnimateTo(Property target, PropertyValue destinationValue, TimePeriod period)
1187         {
1188             Interop.Animation.Animation_AnimateTo__SWIG_2(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), TimePeriod.getCPtr(period));
1189             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1190         }
1191
1192         internal void AnimateTo(Property target, PropertyValue destinationValue, AlphaFunction alpha, TimePeriod period)
1193         {
1194             Interop.Animation.Animation_AnimateTo__SWIG_3(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1195             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1196         }
1197
1198         internal void AnimateBetween(Property target, KeyFrames keyFrames)
1199         {
1200             Interop.Animation.Animation_AnimateBetween__SWIG_0(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames));
1201             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1202         }
1203
1204         internal void AnimateBetween(Property target, KeyFrames keyFrames, Animation.Interpolation interpolation)
1205         {
1206             Interop.Animation.Animation_AnimateBetween__SWIG_1(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), (int)interpolation);
1207             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1208         }
1209
1210         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha)
1211         {
1212             Interop.Animation.Animation_AnimateBetween__SWIG_2(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha));
1213             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1214         }
1215
1216         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, Animation.Interpolation interpolation)
1217         {
1218             Interop.Animation.Animation_AnimateBetween__SWIG_3(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), (int)interpolation);
1219             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1220         }
1221
1222         internal void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period)
1223         {
1224             Interop.Animation.Animation_AnimateBetween__SWIG_4(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period));
1225             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1226         }
1227
1228         internal void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period, Animation.Interpolation interpolation)
1229         {
1230             Interop.Animation.Animation_AnimateBetween__SWIG_5(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period), (int)interpolation);
1231             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1232         }
1233
1234         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period)
1235         {
1236             Interop.Animation.Animation_AnimateBetween__SWIG_6(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1237             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1238         }
1239
1240         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period, Animation.Interpolation interpolation)
1241         {
1242             Interop.Animation.Animation_AnimateBetween__SWIG_7(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period), (int)interpolation);
1243             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1244         }
1245
1246         internal void Animate(View view, Path path, Vector3 forward)
1247         {
1248             Interop.Animation.Animation_Animate__SWIG_0(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward));
1249             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1250         }
1251
1252         internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha)
1253         {
1254             Interop.Animation.Animation_Animate__SWIG_1(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
1255             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1256         }
1257
1258         internal void Animate(View view, Path path, Vector3 forward, TimePeriod period)
1259         {
1260             Interop.Animation.Animation_Animate__SWIG_2(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
1261             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1262         }
1263
1264         internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period)
1265         {
1266             Interop.Animation.Animation_Animate__SWIG_3(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1267             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1268         }
1269
1270         internal void Show(View view, float delaySeconds)
1271         {
1272             Interop.Animation.Animation_Show(swigCPtr, View.getCPtr(view), delaySeconds);
1273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1274         }
1275
1276         internal void Hide(View view, float delaySeconds)
1277         {
1278             Interop.Animation.Animation_Hide(swigCPtr, View.getCPtr(view), delaySeconds);
1279             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1280         }
1281
1282         /// <summary>
1283         /// To make animation instance be disposed.
1284         /// </summary>
1285         /// <since_tizen> 3 </since_tizen>
1286         protected override void Dispose(DisposeTypes type)
1287         {
1288             if (this != null)
1289             {
1290                 if (_animationFinishedEventCallback != null)
1291                 {
1292                     FinishedSignal().Disconnect(_finishedCallbackOfNative);
1293                 }
1294
1295                 if (_animationProgressReachedEventCallback != null)
1296                 {
1297
1298                     ProgressReachedSignal().Disconnect(_animationProgressReachedEventCallback);
1299                 }
1300             }
1301
1302             if(disposed)
1303             {
1304                 return;
1305             }
1306
1307             if (this != null)
1308             {
1309                 this.Clear();
1310             }
1311
1312             //Release your own unmanaged resources here.
1313             //You should not access any managed member here except static instance.
1314             //because the execution order of Finalizes is non-deterministic.
1315
1316             if (swigCPtr.Handle != global::System.IntPtr.Zero)
1317             {
1318                 if (swigCMemOwn)
1319                 {
1320                     swigCMemOwn = false;
1321                     Interop.Animation.delete_Animation(swigCPtr);
1322                 }
1323                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1324             }
1325
1326             base.Dispose(type);
1327         }
1328
1329         private void OnFinished(IntPtr data)
1330         {
1331             if (_animationFinishedEventHandler != null)
1332             {
1333                 //here we send all data to user event handlers
1334                 _animationFinishedEventHandler(this, null);
1335             }
1336         }
1337
1338         private void OnProgressReached(IntPtr data)
1339         {
1340             if (_animationProgressReachedEventHandler != null)
1341             {
1342                 //here we send all data to user event handlers
1343                 _animationProgressReachedEventHandler(this, null);
1344             }
1345         }
1346
1347         private float MilliSecondsToSeconds(int millisec)
1348         {
1349             return (float)millisec / 1000.0f;
1350         }
1351
1352         private int SecondsToMilliSeconds(float sec)
1353         {
1354             return (int)(sec * 1000);
1355         }
1356
1357         private object AvoidFloatPropertyHasIntegerValue(View target, Property property, object value)
1358         {
1359             PropertyType propertyType = target.GetPropertyType(property.propertyIndex);
1360             if (propertyType.Equals(PropertyType.Float))
1361             {
1362                 System.Type type = value.GetType();
1363                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
1364                 {
1365                     int num = (int)value;
1366                     value = (float)num;
1367                 }
1368             }
1369             return value;
1370         }
1371     }
1372 }