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

   1 /*
   2  * Copyright(c) 2018 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         public static Animation DownCast(BaseHandle handle)
 513         {
 514             Animation ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as Animation;
 515             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 516             return ret;
 517         }
 518
 519         /// <summary>
 520         /// Stops the animation.
 521         /// </summary>
 522         /// <param name="action">The end action can be set.</param>
 523         /// <since_tizen> 3 </since_tizen>
 524         public void Stop(EndActions action = EndActions.Cancel)
 525         {
 526             SetEndAction(action);
 527             Interop.Animation.Animation_Stop(swigCPtr);
 528             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 529         }
 530
 531         /// <summary>
 532         /// Animates a property value by a relative amount.<br />
 533         /// </summary>
 534         /// <param name="target">The target object to animate.</param>
 535         /// <param name="property">The target property to animate.</param>
 536         /// <param name="relativeValue">The property value will change by this amount.</param>
 537         /// <param name="alphaFunction">The alpha function to apply.</param>
 538         /// <since_tizen> 3 </since_tizen>
 539         public void AnimateBy(View target, string property, object relativeValue, AlphaFunction alphaFunction = null)
 540         {
 541             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 542
 543             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 544             if (propertyType.Equals(PropertyType.Float))
 545             {
 546                 System.Type type = relativeValue.GetType();
 547                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 548                 {
 549                     int num = (int)relativeValue;
 550                     relativeValue = (float)num;
 551                 }
 552             }
 553
 554             PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
 555
 556             if (alphaFunction != null)
 557             {
 558                 AnimateBy(_prop, val, alphaFunction);
 559             }
 560             else
 561             {
 562                 AnimateBy(_prop, val);
 563             }
 564         }
 565
 566         /// <summary>
 567         /// Animates a property value by a relative amount.<br />
 568         /// </summary>
 569         /// <param name="target">The target object to animate.</param>
 570         /// <param name="property">The target property to animate.</param>
 571         /// <param name="relativeValue">The property value will change by this amount.</param>
 572         /// <param name="startTime">The start time of the animation.</param>
 573         /// <param name="endTime">The end time of the animation.</param>
 574         /// <param name="alphaFunction">The alpha function to apply.</param>
 575         /// <since_tizen> 3 </since_tizen>
 576         public void AnimateBy(View target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
 577         {
 578             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 579
 580             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 581             if (propertyType.Equals(PropertyType.Float))
 582             {
 583                 System.Type type = relativeValue.GetType();
 584                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 585                 {
 586                     int num = (int)relativeValue;
 587                     relativeValue = (float)num;
 588                 }
 589             }
 590
 591             PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
 592
 593             if (alphaFunction != null)
 594             {
 595                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 596                 AnimateBy(_prop, val, alphaFunction, time);
 597             }
 598             else
 599             {
 600                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 601                 AnimateBy(_prop, val, time);
 602             }
 603         }
 604
 605         /// <summary>
 606         /// Animates a property to a destination value.<br />
 607         /// </summary>
 608         /// <param name="target">The target object to animate.</param>
 609         /// <param name="property">The target property to animate.</param>
 610         /// <param name="destinationValue">The destination value.</param>
 611         /// <param name="alphaFunction">The alpha function to apply.</param>
 612         /// <since_tizen> 3 </since_tizen>
 613         public void AnimateTo(View target, string property, object destinationValue, AlphaFunction alphaFunction = null)
 614         {
 615             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 616
 617             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 618             if (propertyType.Equals(PropertyType.Float))
 619             {
 620                 System.Type type = destinationValue.GetType();
 621                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 622                 {
 623                     int num = (int)destinationValue;
 624                     destinationValue = (float)num;
 625                 }
 626             }
 627
 628             PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 629
 630             if (alphaFunction != null)
 631             {
 632                 AnimateTo(_prop, val, alphaFunction);
 633             }
 634             else
 635             {
 636                 AnimateTo(_prop, val);
 637             }
 638         }
 639
 640         /// <summary>
 641         /// Animates one or more properties to a destination value.<br />
 642         /// </summary>
 643         /// <param name="target">The target object to animate.</param>
 644         public void PlayAnimateTo(View target)
 645         {
 646             Clear();
 647             if (_properties.Length == _destValue.Length && _startTime.Length == _endTime.Length && _properties.Length == _startTime.Length)
 648             {
 649                 int length = _properties.Length;
 650                 for (int index = 0; index < length; index++)
 651                 {
 652                     //object destinationValue = _destValue[index];
 653                     var elementType = target.GetType();
 654                     PropertyInfo propertyInfo = elementType.GetProperties().FirstOrDefault(fi => fi.Name == _properties[index]);
 655                     //var propertyInfo = elementType.GetRuntimeProperties().FirstOrDefault(p => p.Name == localName);
 656                     if (propertyInfo != null)
 657                     {
 658                         object destinationValue = ConvertTo(_destValue[index], propertyInfo.PropertyType);
 659
 660                         if (destinationValue != null)
 661                         {
 662                             AnimateTo(target, _properties[index], destinationValue, _startTime[index], _endTime[index]);
 663                         }
 664                     }
 665                 }
 666                 Play();
 667             }
 668         }
 669
 670         /// <summary>
 671         /// Animates a property to a destination value.<br />
 672         /// </summary>
 673         /// <param name="target">The target object to animate.</param>
 674         /// <param name="property">The target property to animate.</param>
 675         /// <param name="destinationValue">The destination value.</param>
 676         /// <param name="startTime">The start time of the animation.</param>
 677         /// <param name="endTime">The end time of the animation.</param>
 678         /// <param name="alphaFunction">The alpha function to apply.</param>
 679         /// <since_tizen> 3 </since_tizen>
 680         public void AnimateTo(View target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
 681         {
 682             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 683
 684             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 685             if (propertyType.Equals(PropertyType.Float))
 686             {
 687                 System.Type type = destinationValue.GetType();
 688                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 689                 {
 690                     int num = (int)destinationValue;
 691                     destinationValue = (float)num;
 692                 }
 693             }
 694
 695             PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 696
 697             if (alphaFunction != null)
 698             {
 699                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 700                 AnimateTo(_prop, val, alphaFunction, time);
 701             }
 702             else
 703             {
 704                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 705                 AnimateTo(_prop, val, time);
 706             }
 707         }
 708
 709         /// <summary>
 710         /// Animates a property between keyframes.
 711         /// </summary>
 712         /// <param name="target">The target object to animate.</param>
 713         /// <param name="property">The target property to animate.</param>
 714         /// <param name="keyFrames">The set of time or value pairs between which to animate.</param>
 715         /// <param name="interpolation">The method used to interpolate between values.</param>
 716         /// <param name="alphaFunction">The alpha function to apply.</param>
 717         /// <since_tizen> 3 </since_tizen>
 718         public void AnimateBetween(View target, string property, KeyFrames keyFrames, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
 719         {
 720             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 721
 722             if (_prop.propertyIndex == Property.INVALID_INDEX)
 723             {
 724                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 725             }
 726
 727             if (alphaFunction != null)
 728             {
 729                 AnimateBetween(_prop, keyFrames, alphaFunction, interpolation);
 730             }
 731             else
 732             {
 733                 AnimateBetween(_prop, keyFrames, interpolation);
 734             }
 735         }
 736
 737         /// <summary>
 738         /// Animates a property between keyframes.
 739         /// </summary>
 740         /// <param name="target">The target object to animate</param>
 741         /// <param name="property">The target property to animate</param>
 742         /// <param name="keyFrames">The set of time/value pairs between which to animate</param>
 743         /// <param name="startTime">The start time of animation in milliseconds.</param>
 744         /// <param name="endTime">The end time of animation in milliseconds.</param>
 745         /// <param name="interpolation">The method used to interpolate between values.</param>
 746         /// <param name="alphaFunction">The alpha function to apply.</param>
 747         /// <since_tizen> 3 </since_tizen>
 748         public void AnimateBetween(View target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
 749         {
 750             Property _prop = PropertyHelper.GetPropertyFromString(target, property);
 751
 752             Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 753             if (alphaFunction != null)
 754             {
 755                 AnimateBetween(_prop, keyFrames, alphaFunction, time, interpolation);
 756             }
 757             else
 758             {
 759                 AnimateBetween(_prop, keyFrames, time, interpolation);
 760             }
 761         }
 762
 763         /// <summary>
 764         /// Animates the view's position and orientation through a predefined path.<br />
 765         /// The view will rotate to orient the supplied forward vector with the path's tangent.<br />
 766         /// If forward is the zero vector then no rotation will happen.<br />
 767         /// </summary>
 768         /// <param name="view">The view to animate.</param>
 769         /// <param name="path">It defines position and orientation.</param>
 770         /// <param name="forward">The vector (in local space coordinate system) will be oriented with the path's tangent direction.</param>
 771         /// <param name="alphaFunction">The alpha function to apply.</param>
 772         /// <since_tizen> 3 </since_tizen>
 773         public void AnimatePath(View view, Path path, Vector3 forward, AlphaFunction alphaFunction = null)
 774         {
 775             if (alphaFunction == null)
 776             {
 777                 Animate(view, path, forward);
 778             }
 779             else
 780             {
 781                 Animate(view, path, forward, alphaFunction);
 782             }
 783         }
 784
 785         /// <summary>
 786         /// Animates the view's position and orientation through a predefined path.<br />
 787         /// The view will rotate to orient the supplied forward vector with the path's tangent.<br />
 788         /// If forward is the zero vector then no rotation will happen.<br />
 789         /// </summary>
 790         /// <param name="view">The view to animate.</param>
 791         /// <param name="path">It defines position and orientation.</param>
 792         /// <param name="forward">The vector (in local space coordinate system) will be oriented with the path's tangent direction.</param>
 793         /// <param name="startTime">The start time of the animation.</param>
 794         /// <param name="endTime">The end time of the animation.</param>
 795         /// <param name="alphaFunction">The alpha function to apply.</param>
 796         /// <since_tizen> 3 </since_tizen>
 797         public void AnimatePath(View view, Path path, Vector3 forward, int startTime, int endTime, AlphaFunction alphaFunction = null)
 798         {
 799             TimePeriod time = new TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 800             if (alphaFunction == null)
 801             {
 802                 Animate(view, path, forward, time);
 803             }
 804             else
 805             {
 806                 Animate(view, path, forward, alphaFunction, time);
 807             }
 808         }
 809
 810         /// <summary>
 811         /// Creates an initialized animation.<br />
 812         /// The animation will not loop.<br />
 813         /// The default end action is "Cancel".<br />
 814         /// The default alpha function is linear.<br />
 815         /// </summary>
 816         /// <since_tizen> 3 </since_tizen>
 817         public Animation() : this(Interop.Animation.Animation_New(0.0f), true)
 818         {
 819             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 820         }
 821
 822         /// <summary>
 823         /// Plays the animation.
 824         /// </summary>
 825         /// <since_tizen> 3 </since_tizen>
 826         public void Play()
 827         {
 828             Interop.Animation.Animation_Play(swigCPtr);
 829             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 830
 831             if (DisableAnimation == true)
 832                 Stop(EndActions.StopFinal);
 833         }
 834
 835         /// <summary>
 836         /// Plays the animation from a given point.<br />
 837         /// The progress must be in the 0-1 interval or in the play range interval if defined,
 838         /// otherwise, it will be ignored.<br />
 839         /// </summary>
 840         /// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing.</param>
 841         /// <since_tizen> 3 </since_tizen>
 842         public void PlayFrom(float progress)
 843         {
 844             Interop.Animation.Animation_PlayFrom(swigCPtr, progress);
 845             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 846         }
 847
 848         /// <summary>
 849         /// Plays the animation after a given delay time.<br/>
 850         /// The delay time is not included in the looping time.<br/>
 851         /// When the delay time is a negative value, it would treat as play immediately.<br/>
 852         /// </summary>
 853         /// <param name="delayMilliseconds">The delay time.</param>
 854         /// <since_tizen> 4 </since_tizen>
 855         public void PlayAfter(int delayMilliseconds)
 856         {
 857             Interop.Animation.Animation_PlayAfter(swigCPtr, MilliSecondsToSeconds(delayMilliseconds));
 858             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 859         }
 860
 861         /// <summary>
 862         /// Pauses the animation.
 863         /// </summary>
 864         /// <since_tizen> 3 </since_tizen>
 865         public void Pause()
 866         {
 867             Interop.Animation.Animation_Pause(swigCPtr);
 868             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 869         }
 870
 871         /// <summary>
 872         /// Stops the animation.
 873         /// </summary>
 874         /// <since_tizen> 3 </since_tizen>
 875         public void Stop()
 876         {
 877             Interop.Animation.Animation_Stop(swigCPtr);
 878             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 879         }
 880
 881         /// <summary>
 882         /// Clears the animation.<br />
 883         /// This disconnects any objects that were being animated, effectively stopping the animation.<br />
 884         /// </summary>
 885         /// <since_tizen> 3 </since_tizen>
 886         public void Clear()
 887         {
 888             Interop.Animation.Animation_Clear(swigCPtr);
 889             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 890         }
 891
 892         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animation obj)
 893         {
 894             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 895         }
 896
 897         internal object ConvertTo(object value, Type toType)
 898         {
 899             Func<object> getConverter = () =>
 900             {
 901                 string converterTypeName = GetTypeConverterTypeName(toType.GetTypeInfo().CustomAttributes);
 902                 if (converterTypeName == null)
 903                     return null;
 904
 905                 Type convertertype = Type.GetType(converterTypeName);
 906                 return Activator.CreateInstance(convertertype);
 907             };
 908
 909             return ConvertTo(value, toType, getConverter);
 910         }
 911
 912         internal object ConvertTo(object value, Type toType, Func<object> getConverter)
 913         {
 914             if (value == null)
 915                 return null;
 916
 917             var str = value as string;
 918             if (str != null)
 919             {
 920                 //If there's a [TypeConverter], use it
 921                 object converter = getConverter?.Invoke();
 922                 var xfTypeConverter = converter as Tizen.NUI.Binding.TypeConverter;
 923                 if (xfTypeConverter != null)
 924                     return value = xfTypeConverter.ConvertFromInvariantString(str);
 925                 var converterType = converter?.GetType();
 926                 if (converterType != null)
 927                 {
 928                     var convertFromStringInvariant = converterType.GetRuntimeMethod("ConvertFromInvariantString",
 929                         new[] { typeof(string) });
 930                     if (convertFromStringInvariant != null)
 931                         return value = convertFromStringInvariant.Invoke(converter, new object[] { str });
 932                 }
 933
 934                 //If the type is nullable, as the value is not null, it's safe to assume we want the built-in conversion
 935                 if (toType.GetTypeInfo().IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable<>))
 936                     toType = Nullable.GetUnderlyingType(toType);
 937
 938                 //Obvious Built-in conversions
 939                 if (toType.GetTypeInfo().IsEnum)
 940                     return Enum.Parse(toType, str, true);
 941                 if (toType == typeof(SByte))
 942                     return SByte.Parse(str, CultureInfo.InvariantCulture);
 943                 if (toType == typeof(Int16))
 944                     return Int16.Parse(str, CultureInfo.InvariantCulture);
 945                 if (toType == typeof(Int32))
 946                     return Int32.Parse(str, CultureInfo.InvariantCulture);
 947                 if (toType == typeof(Int64))
 948                     return Int64.Parse(str, CultureInfo.InvariantCulture);
 949                 if (toType == typeof(Byte))
 950                     return Byte.Parse(str, CultureInfo.InvariantCulture);
 951                 if (toType == typeof(UInt16))
 952                     return UInt16.Parse(str, CultureInfo.InvariantCulture);
 953                 if (toType == typeof(UInt32))
 954                     return UInt32.Parse(str, CultureInfo.InvariantCulture);
 955                 if (toType == typeof(UInt64))
 956                     return UInt64.Parse(str, CultureInfo.InvariantCulture);
 957                 if (toType == typeof(Single))
 958                     return Single.Parse(str, CultureInfo.InvariantCulture);
 959                 if (toType == typeof(Double))
 960                     return Double.Parse(str, CultureInfo.InvariantCulture);
 961                 if (toType == typeof(Boolean))
 962                     return Boolean.Parse(str);
 963                 if (toType == typeof(TimeSpan))
 964                     return TimeSpan.Parse(str, CultureInfo.InvariantCulture);
 965                 if (toType == typeof(DateTime))
 966                     return DateTime.Parse(str, CultureInfo.InvariantCulture);
 967                 if (toType == typeof(Char))
 968                 {
 969                     char c = '\0';
 970                     Char.TryParse(str, out c);
 971                     return c;
 972                 }
 973                 if (toType == typeof(String) && str.StartsWith("{}", StringComparison.Ordinal))
 974                     return str.Substring(2);
 975                 if (toType == typeof(String))
 976                     return value;
 977                 if (toType == typeof(Decimal))
 978                     return Decimal.Parse(str, CultureInfo.InvariantCulture);
 979             }
 980
 981             //if the value is not assignable and there's an implicit conversion, convert
 982             if (value != null && !toType.IsAssignableFrom(value.GetType()))
 983             {
 984                 var opImplicit = GetImplicitConversionOperator(value.GetType(), value.GetType(), toType)
 985                                  ?? GetImplicitConversionOperator(toType, value.GetType(), toType);
 986                 //var opImplicit = value.GetType().GetImplicitConversionOperator(fromType: value.GetType(), toType: toType)
 987                 //                ?? toType.GetImplicitConversionOperator(fromType: value.GetType(), toType: toType);
 988
 989                 if (opImplicit != null)
 990                 {
 991                     value = opImplicit.Invoke(null, new[] { value });
 992                     return value;
 993                 }
 994             }
 995
 996             return value;
 997         }
 998
 999         internal string GetTypeConverterTypeName(IEnumerable<CustomAttributeData> attributes)
1000         {
1001             var converterAttribute =
1002                 attributes.FirstOrDefault(cad => Tizen.NUI.Binding.TypeConverterAttribute.TypeConvertersType.Contains(cad.AttributeType.FullName));
1003             if (converterAttribute == null)
1004                 return null;
1005             if (converterAttribute.ConstructorArguments[0].ArgumentType == typeof(string))
1006                 return (string)converterAttribute.ConstructorArguments[0].Value;
1007             if (converterAttribute.ConstructorArguments[0].ArgumentType == typeof(Type))
1008                 return ((Type)converterAttribute.ConstructorArguments[0].Value).AssemblyQualifiedName;
1009             return null;
1010         }
1011
1012         internal MethodInfo GetImplicitConversionOperator(Type onType, Type fromType, Type toType)
1013         {
1014 #if NETSTANDARD1_0
1015             var mi = onType.GetRuntimeMethod("op_Implicit", new[] { fromType });
1016 #else
1017             var bindingFlags = BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy;
1018             var mi = onType.GetMethod("op_Implicit", bindingFlags, null, new[] { fromType }, null);
1019 #endif
1020             if (mi == null) return null;
1021             if (!mi.IsSpecialName) return null;
1022             if (!mi.IsPublic) return null;
1023             if (!mi.IsStatic) return null;
1024             if (!toType.IsAssignableFrom(mi.ReturnType)) return null;
1025
1026             return mi;
1027         }
1028
1029         internal Animation(float durationSeconds) : this(Interop.Animation.Animation_New(durationSeconds), true)
1030         {
1031             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1032
1033         }
1034
1035         internal Animation(Animation handle) : this(Interop.Animation.new_Animation__SWIG_1(Animation.getCPtr(handle)), true)
1036         {
1037             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1038         }
1039
1040         internal Animation Assign(Animation rhs)
1041         {
1042             Animation ret = new Animation(Interop.Animation.Animation_Assign(swigCPtr, Animation.getCPtr(rhs)), false);
1043             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1044             return ret;
1045         }
1046
1047         internal void SetDuration(float seconds)
1048         {
1049             Interop.Animation.Animation_SetDuration(swigCPtr, seconds);
1050             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1051         }
1052
1053         internal float GetDuration()
1054         {
1055             float ret = Interop.Animation.Animation_GetDuration(swigCPtr);
1056             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1057             return ret;
1058         }
1059
1060         internal void SetLooping(bool looping)
1061         {
1062             Interop.Animation.Animation_SetLooping(swigCPtr, looping);
1063             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1064         }
1065
1066         internal void SetLoopCount(int count)
1067         {
1068             Interop.Animation.Animation_SetLoopCount(swigCPtr, count);
1069             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1070         }
1071
1072         internal int GetLoopCount()
1073         {
1074             int ret = Interop.Animation.Animation_GetLoopCount(swigCPtr);
1075             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1076             return ret;
1077         }
1078
1079         internal int GetCurrentLoop()
1080         {
1081             int ret = Interop.Animation.Animation_GetCurrentLoop(swigCPtr);
1082             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1083             return ret;
1084         }
1085
1086         internal bool IsLooping()
1087         {
1088             bool ret = Interop.Animation.Animation_IsLooping(swigCPtr);
1089             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1090             return ret;
1091         }
1092
1093         internal void SetEndAction(Animation.EndActions action)
1094         {
1095             Interop.Animation.Animation_SetEndAction(swigCPtr, (int)action);
1096             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1097         }
1098
1099         internal Animation.EndActions GetEndAction()
1100         {
1101             Animation.EndActions ret = (Animation.EndActions)Interop.Animation.Animation_GetEndAction(swigCPtr);
1102             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1103             return ret;
1104         }
1105
1106         internal void SetDisconnectAction(Animation.EndActions disconnectAction)
1107         {
1108             Interop.Animation.Animation_SetDisconnectAction(swigCPtr, (int)disconnectAction);
1109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1110         }
1111
1112         internal Animation.EndActions GetDisconnectAction()
1113         {
1114             Animation.EndActions ret = (Animation.EndActions)Interop.Animation.Animation_GetDisconnectAction(swigCPtr);
1115             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1116             return ret;
1117         }
1118
1119         internal void SetDefaultAlphaFunction(AlphaFunction alpha)
1120         {
1121             Interop.Animation.Animation_SetDefaultAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
1122             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1123         }
1124
1125         internal AlphaFunction GetDefaultAlphaFunction()
1126         {
1127             AlphaFunction ret = new AlphaFunction(Interop.Animation.Animation_GetDefaultAlphaFunction(swigCPtr), true);
1128             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1129             return ret;
1130         }
1131
1132         internal void SetCurrentProgress(float progress)
1133         {
1134             Interop.Animation.Animation_SetCurrentProgress(swigCPtr, progress);
1135             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1136         }
1137
1138         internal float GetCurrentProgress()
1139         {
1140             float ret = Interop.Animation.Animation_GetCurrentProgress(swigCPtr);
1141             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1142             return ret;
1143         }
1144
1145         internal void SetSpeedFactor(float factor)
1146         {
1147             Interop.Animation.Animation_SetSpeedFactor(swigCPtr, factor);
1148             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1149         }
1150
1151         internal float GetSpeedFactor()
1152         {
1153             float ret = Interop.Animation.Animation_GetSpeedFactor(swigCPtr);
1154             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1155             return ret;
1156         }
1157
1158         internal void SetPlayRange(Vector2 range)
1159         {
1160             Interop.Animation.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(range));
1161             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1162         }
1163
1164         internal Vector2 GetPlayRange()
1165         {
1166             Vector2 ret = new Vector2(Interop.Animation.Animation_GetPlayRange(swigCPtr), true);
1167             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1168             return ret;
1169         }
1170
1171         internal Animation.States GetState()
1172         {
1173             Animation.States ret = (Animation.States)Interop.Animation.Animation_GetState(swigCPtr);
1174             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1175             return ret;
1176         }
1177
1178         internal AnimationSignal FinishedSignal()
1179         {
1180             AnimationSignal ret = new AnimationSignal(Interop.Animation.Animation_FinishedSignal(swigCPtr), false);
1181             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1182             return ret;
1183         }
1184
1185         internal AnimationSignal ProgressReachedSignal()
1186         {
1187             AnimationSignal ret = new AnimationSignal(Interop.Animation.Animation_ProgressReachedSignal(swigCPtr), false);
1188             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1189             return ret;
1190         }
1191
1192         internal void AnimateBy(Property target, PropertyValue relativeValue)
1193         {
1194             Interop.Animation.Animation_AnimateBy__SWIG_0(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue));
1195             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1196         }
1197
1198         internal void AnimateBy(Property target, PropertyValue relativeValue, AlphaFunction alpha)
1199         {
1200             Interop.Animation.Animation_AnimateBy__SWIG_1(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha));
1201             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1202         }
1203
1204         internal void AnimateBy(Property target, PropertyValue relativeValue, TimePeriod period)
1205         {
1206             Interop.Animation.Animation_AnimateBy__SWIG_2(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), TimePeriod.getCPtr(period));
1207             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1208         }
1209
1210         internal void AnimateBy(Property target, PropertyValue relativeValue, AlphaFunction alpha, TimePeriod period)
1211         {
1212             Interop.Animation.Animation_AnimateBy__SWIG_3(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1213             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1214         }
1215
1216         internal void AnimateTo(Property target, PropertyValue destinationValue)
1217         {
1218             Interop.Animation.Animation_AnimateTo__SWIG_0(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue));
1219             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1220         }
1221
1222         internal void AnimateTo(Property target, PropertyValue destinationValue, AlphaFunction alpha)
1223         {
1224             Interop.Animation.Animation_AnimateTo__SWIG_1(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha));
1225             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1226         }
1227
1228         internal void AnimateTo(Property target, PropertyValue destinationValue, TimePeriod period)
1229         {
1230             Interop.Animation.Animation_AnimateTo__SWIG_2(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), TimePeriod.getCPtr(period));
1231             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1232         }
1233
1234         internal void AnimateTo(Property target, PropertyValue destinationValue, AlphaFunction alpha, TimePeriod period)
1235         {
1236             Interop.Animation.Animation_AnimateTo__SWIG_3(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), 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)
1241         {
1242             Interop.Animation.Animation_AnimateBetween__SWIG_0(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames));
1243             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1244         }
1245
1246         internal void AnimateBetween(Property target, KeyFrames keyFrames, Animation.Interpolation interpolation)
1247         {
1248             Interop.Animation.Animation_AnimateBetween__SWIG_1(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), (int)interpolation);
1249             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1250         }
1251
1252         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha)
1253         {
1254             Interop.Animation.Animation_AnimateBetween__SWIG_2(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha));
1255             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1256         }
1257
1258         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, Animation.Interpolation interpolation)
1259         {
1260             Interop.Animation.Animation_AnimateBetween__SWIG_3(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), (int)interpolation);
1261             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1262         }
1263
1264         internal void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period)
1265         {
1266             Interop.Animation.Animation_AnimateBetween__SWIG_4(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period));
1267             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1268         }
1269
1270         internal void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period, Animation.Interpolation interpolation)
1271         {
1272             Interop.Animation.Animation_AnimateBetween__SWIG_5(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period), (int)interpolation);
1273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1274         }
1275
1276         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period)
1277         {
1278             Interop.Animation.Animation_AnimateBetween__SWIG_6(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1279             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1280         }
1281
1282         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period, Animation.Interpolation interpolation)
1283         {
1284             Interop.Animation.Animation_AnimateBetween__SWIG_7(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period), (int)interpolation);
1285             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1286         }
1287
1288         internal void Animate(View view, Path path, Vector3 forward)
1289         {
1290             Interop.Animation.Animation_Animate__SWIG_0(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward));
1291             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1292         }
1293
1294         internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha)
1295         {
1296             Interop.Animation.Animation_Animate__SWIG_1(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
1297             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1298         }
1299
1300         internal void Animate(View view, Path path, Vector3 forward, TimePeriod period)
1301         {
1302             Interop.Animation.Animation_Animate__SWIG_2(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
1303             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1304         }
1305
1306         internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period)
1307         {
1308             Interop.Animation.Animation_Animate__SWIG_3(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1309             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1310         }
1311
1312         internal void Show(View view, float delaySeconds)
1313         {
1314             Interop.Animation.Animation_Show(swigCPtr, View.getCPtr(view), delaySeconds);
1315             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1316         }
1317
1318         internal void Hide(View view, float delaySeconds)
1319         {
1320             Interop.Animation.Animation_Hide(swigCPtr, View.getCPtr(view), delaySeconds);
1321             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1322         }
1323
1324         /// <summary>
1325         /// To make animation instance be disposed.
1326         /// </summary>
1327         /// <since_tizen> 3 </since_tizen>
1328         protected override void Dispose(DisposeTypes type)
1329         {
1330             if (this != null)
1331             {
1332                 if (_animationFinishedEventCallback != null)
1333                 {
1334                     FinishedSignal().Disconnect(_finishedCallbackOfNative);
1335                 }
1336
1337                 if (_animationProgressReachedEventCallback != null)
1338                 {
1339
1340                     ProgressReachedSignal().Disconnect(_animationProgressReachedEventCallback);
1341                 }
1342             }
1343
1344             if(disposed)
1345             {
1346                 return;
1347             }
1348             if(type == DisposeTypes.Explicit)
1349             {
1350                 //Called by User
1351                 //Release your own managed resources here.
1352                 //You should release all of your own disposable objects here.
1353
1354             }
1355             else if(type == DisposeTypes.Implicit)
1356             {
1357
1358             }
1359
1360             if (this != null)
1361             {
1362                 this.Clear();
1363             }
1364
1365             //Release your own unmanaged resources here.
1366             //You should not access any managed member here except static instance.
1367             //because the execution order of Finalizes is non-deterministic.
1368
1369             if (swigCPtr.Handle != global::System.IntPtr.Zero)
1370             {
1371                 if (swigCMemOwn)
1372                 {
1373                     swigCMemOwn = false;
1374                     Interop.Animation.delete_Animation(swigCPtr);
1375                 }
1376                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1377             }
1378
1379             base.Dispose(type);
1380         }
1381
1382         private void OnFinished(IntPtr data)
1383         {
1384             if (_animationFinishedEventHandler != null)
1385             {
1386                 //here we send all data to user event handlers
1387                 _animationFinishedEventHandler(this, null);
1388             }
1389         }
1390
1391         private void OnProgressReached(IntPtr data)
1392         {
1393             if (_animationProgressReachedEventHandler != null)
1394             {
1395                 //here we send all data to user event handlers
1396                 _animationProgressReachedEventHandler(this, null);
1397             }
1398         }
1399
1400         private float MilliSecondsToSeconds(int millisec)
1401         {
1402             return (float)millisec / 1000.0f;
1403         }
1404
1405         private int SecondsToMilliSeconds(float sec)
1406         {
1407             return (int)(sec * 1000);
1408         }
1409
1410     }
1411
1412 }