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

   1 // Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14 //
  15 //
  16 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
  17 // Some have been manually changed
  18
  19 namespace Tizen.NUI
  20 {
  21
  22     using System;
  23     using System.Runtime.InteropServices;
  24     using Tizen.NUI.BaseComponents;
  25
  26     /// <summary>
  27     /// Animation can be used to animate the properties of any number of objects, typically View.<br>
  28     /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.<br>
  29     /// This is typically done in the object destructor, and requires either the Animation handle to be stored.<br>
  30     /// 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>
  31     /// If any of the individual calls to those functions exceeds the overall animation time(Duration), then the overall animation time is automatically extended.<br>
  32     /// </summary>
  33     public class Animation : BaseHandle
  34     {
  35         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  36
  37         internal Animation(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Animation_SWIGUpcast(cPtr), cMemoryOwn)
  38         {
  39             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  40         }
  41
  42         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Animation obj)
  43         {
  44             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  45         }
  46
  47         /// <summary>
  48         /// To make Animation instance be disposed.
  49         /// </summary>
  50         protected override void Dispose(DisposeTypes type)
  51         {
  52             if(disposed)
  53             {
  54                 return;
  55             }
  56             if(type == DisposeTypes.Explicit)
  57             {
  58                 //Called by User
  59                 //Release your own managed resources here.
  60                 //You should release all of your own disposable objects here.
  61
  62             }
  63             else if(type == DisposeTypes.Implicit)
  64             {
  65
  66             }
  67
  68             if(this)
  69             {
  70                 this.Clear();
  71                 this.Reset();
  72                 NUILog.Error("Now Animation is playing! Clear and Reset here!");
  73                 //throw new System.InvalidOperationException("Animation Instance should not be disposed until getting Finished event. Should be a global variable");
  74             }
  75
  76
  77             //Release your own unmanaged resources here.
  78             //You should not access any managed member here except static instance.
  79             //because the execution order of Finalizes is non-deterministic.
  80
  81             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  82             {
  83                 if (swigCMemOwn)
  84                 {
  85                     swigCMemOwn = false;
  86                     NDalicPINVOKE.delete_Animation(swigCPtr);
  87                 }
  88                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  89             }
  90
  91             base.Dispose(type);
  92         }
  93
  94         /// <summary>
  95         /// Create an initialized Animation.<br>
  96         /// The animation will not loop.<br>
  97         /// The default end action is "Cancel".<br>
  98         /// The default Alpha function is linear.<br>
  99         /// </summary>
 100         /// <remarks>DurationmSeconds must be greater than zero.</remarks>
 101         /// <param name="durationMilliSeconds">The duration in milli seconds.</param>
 102         public Animation(int durationMilliSeconds) : this(NDalicPINVOKE.Animation_New((float)durationMilliSeconds / 1000.0f), true)
 103         {
 104             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 105         }
 106
 107         private AnimationFinishedEventCallbackType _animationFinishedEventCallback;
 108         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 109         private delegate void AnimationFinishedEventCallbackType(IntPtr data);
 110         private event EventHandler _animationFinishedEventHandler;
 111         /**
 112         * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler.
 113         * Finished signal is emitted when an Animation's animations have finished.
 114         */
 115         public event EventHandler Finished
 116         {
 117             add
 118             {
 119                 if (_animationFinishedEventHandler == null)
 120                 {
 121                     NUILog.Debug("[add before]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 122                     _animationFinishedEventCallback = OnFinished;
 123                     FinishedSignal().Connect(_animationFinishedEventCallback);
 124                     NUILog.Debug("[add after]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 125                 }
 126                 _animationFinishedEventHandler += value;
 127             }
 128             remove
 129             {
 130                 _animationFinishedEventHandler -= value;
 131
 132                 if (_animationFinishedEventHandler == null && FinishedSignal().Empty() == false)
 133                 {
 134                     NUILog.Debug("[remove before]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 135                     FinishedSignal().Disconnect(_animationFinishedEventCallback);
 136                     NUILog.Debug("[remove after]FinishedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 137                 }
 138             }
 139         }
 140         private void OnFinished(IntPtr data)
 141         {
 142             if (_animationFinishedEventHandler != null)
 143             {
 144                 //here we send all data to user event handlers
 145                 _animationFinishedEventHandler(this, null);
 146             }
 147         }
 148
 149         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 150         private delegate void AnimationProgressReachedEventCallbackType(IntPtr data);
 151         private AnimationProgressReachedEventCallbackType _animationProgressReachedEventCallback;
 152         private event EventHandler _animationProgressReachedEventHandler;
 153         /**
 154         * @brief Event for ProgressReached signal which can be used to subscribe/unsubscribe the event handler.
 155         * ProgressReached signal is emitted when the Animation has reached a given progress percentage, this is set in the api SetProgressNotification.
 156         */
 157         public event EventHandler ProgressReached
 158         {
 159             add
 160             {
 161                 if (_animationProgressReachedEventHandler == null)
 162                 {
 163                     NUILog.Debug("[add before]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 164                     _animationProgressReachedEventCallback = OnProgressReached;
 165                     ProgressReachedSignal().Connect(_animationProgressReachedEventCallback);
 166                     NUILog.Debug("[add after]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 167                 }
 168
 169                 _animationProgressReachedEventHandler += value;
 170             }
 171             remove
 172             {
 173                 _animationProgressReachedEventHandler -= value;
 174
 175                 if (_animationProgressReachedEventHandler == null && ProgressReachedSignal().Empty() == false)
 176                 {
 177                     NUILog.Debug("[remove before]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 178                     ProgressReachedSignal().Disconnect(_animationProgressReachedEventHandler);
 179                     NUILog.Debug("[remove after]ProgressReachedSignal().Empty=" + FinishedSignal().Empty() + " GetConnectionCount=" + FinishedSignal().GetConnectionCount());
 180                 }
 181             }
 182         }
 183         private void OnProgressReached(IntPtr data)
 184         {
 185             if (_animationProgressReachedEventHandler != null)
 186             {
 187                 //here we send all data to user event handlers
 188                 _animationProgressReachedEventHandler(this, null);
 189             }
 190         }
 191
 192         private float MilliSecondsToSeconds(int millisec)
 193         {
 194             return (float)millisec / 1000.0f;
 195         }
 196
 197         private int SecondsToMilliSeconds(float sec)
 198         {
 199             return (int)(sec * 1000);
 200         }
 201
 202
 203         /// <summary>
 204         /// Gets/Sets the duration in milli seconds of the animation.
 205         /// </summary>
 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/Sets the default alpha function for the animation.
 220         /// </summary>
 221         public AlphaFunction DefaultAlphaFunction
 222         {
 223             set
 224             {
 225                 SetDefaultAlphaFunction(value);
 226             }
 227             get
 228             {
 229                 AlphaFunction ret = GetDefaultAlphaFunction();
 230                 return ret;
 231             }
 232         }
 233
 234         /// <summary>
 235         /// Queries the state of the animation.
 236         /// </summary>
 237         public States State
 238         {
 239             get
 240             {
 241                 return GetState();
 242             }
 243         }
 244
 245         /// <summary>
 246         /// Set : Enables looping for 'count' repeats. A zero is the same as Looping = true; i.e.repeat forever.<br>
 247         /// If Play() Stop() or 'count' loops is reached, the loop counter will reset.<br>
 248         /// Setting this parameter does not cause the animation to Play().<br>
 249         /// Get : Gets the loop count. A zero is the same as Looping = true; ie repeat forever.<br>
 250         /// The loop count is initially 1 for play once.<br>
 251         /// </summary>
 252         public int LoopCount
 253         {
 254             set
 255             {
 256                 SetLoopCount(value);
 257             }
 258             get
 259             {
 260                 int ret = GetLoopCount();
 261                 return ret;
 262             }
 263         }
 264
 265         /// <summary>
 266         /// Gets/Sets the status of whether the animation will loop.<br>
 267         /// This property resets the loop count and should not be used with LoopCount property.<br>
 268         /// Setting this parameter does not cause the animation to Play().<br>
 269         /// </summary>
 270         public bool Looping
 271         {
 272             set
 273             {
 274                 SetLooping(value);
 275             }
 276             get
 277             {
 278                 bool ret = IsLooping();
 279                 return ret;
 280             }
 281         }
 282
 283
 284         /// <summary>
 285         /// Gets/Sets the end action of the animation.<br>
 286         /// This action is performed when the animation ends or if it is stopped.<br>
 287         /// Default end action is Cancel.<br>
 288         /// </summary>
 289         public EndActions EndAction
 290         {
 291             set
 292             {
 293                 SetEndAction(value);
 294             }
 295             get
 296             {
 297                 return GetEndAction();
 298             }
 299         }
 300
 301
 302         /// <summary>
 303         /// Stops the animation.
 304         /// </summary>
 305         /// <param name="action">end action can be set</param>
 306         public void Stop(EndActions action = EndActions.Cancel)
 307         {
 308             SetEndAction(action);
 309             NDalicPINVOKE.Animation_Stop(swigCPtr);
 310             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 311         }
 312
 313         /// <summary>
 314         /// Gets the current loop count.<br>
 315         /// A value 0 indicating the current loop count when looping.<br>
 316         /// </summary>
 317         public int CurrentLoop
 318         {
 319             get
 320             {
 321                 return GetCurrentLoop();
 322             }
 323         }
 324
 325         /// <summary>
 326         /// Gets/Sets the disconnect action.<br>
 327         /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.<br>
 328         /// Default action is to Cancel.<br>
 329         /// </summary>
 330         public EndActions DisconnectAction
 331         {
 332             set
 333             {
 334                 NDalicPINVOKE.Animation_SetDisconnectAction(swigCPtr, (int)value);
 335                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 336             }
 337             get
 338             {
 339                 Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetDisconnectAction(swigCPtr);
 340                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 341                 return ret;
 342             }
 343         }
 344
 345
 346         /// <summary>
 347         /// Gets/Sets the progress of the animation.<br>
 348         /// The animation will play(or continue playing) from this point.<br>
 349         /// The progress must be in the 0-1 interval or in the play range interval if defined.<br>
 350         /// otherwise, it will be ignored.<br>
 351         /// </summary>
 352         public float CurrentProgress
 353         {
 354             set
 355             {
 356                 NDalicPINVOKE.Animation_SetCurrentProgress(swigCPtr, value);
 357                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 358             }
 359             get
 360             {
 361                 float ret = NDalicPINVOKE.Animation_GetCurrentProgress(swigCPtr);
 362                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 363                 return ret;
 364             }
 365         }
 366
 367         /// <summary>
 368         /// Gets/Sets Specifies a speed factor for the animation.<br>
 369         /// The speed factor is a multiplier of the normal velocity of the animation.<br>
 370         /// Values between[0, 1] will slow down the animation and values above one will speed up the animation.<br>
 371         /// It is also possible to specify a negative multiplier to play the animation in reverse.<br>
 372         /// </summary>
 373         public float SpeedFactor
 374         {
 375             set
 376             {
 377                 NDalicPINVOKE.Animation_SetSpeedFactor(swigCPtr, value);
 378                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 379             }
 380             get
 381             {
 382                 float ret = NDalicPINVOKE.Animation_GetSpeedFactor(swigCPtr);
 383                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 384                 return ret;
 385             }
 386         }
 387
 388         /// <summary>
 389         /// Gets/Sets the playing range.<br>
 390         /// Animation will play between the values specified. Both values(range.x and range.y ) should be between 0-1,
 391         /// otherwise they will be ignored.If the range provided is not in proper order(minimum, maximum ), it will be reordered.<br>
 392         /// </summary>
 393         public RelativeVector2 PlayRange
 394         {
 395             set
 396             {
 397                 NDalicPINVOKE.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(value));
 398                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 399             }
 400             get
 401             {
 402                 Vector2 ret = new Vector2(NDalicPINVOKE.Animation_GetPlayRange(swigCPtr), true);
 403                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 404                 return ret;
 405             }
 406         }
 407
 408
 409         /// <summary>
 410         /// Gets/Sets the Progress notification marker which triggers the ProgressReachedSignal.<br>
 411         /// percentage of animation progress should be greater than 0 and less than 1, e.g 0.3 for 30% <br>
 412         /// One notification can be set on each animation
 413         /// </summary>
 414         public float ProgressNotification
 415         {
 416             set
 417             {
 418                 NDalicPINVOKE.Animation_SetProgressNotification(swigCPtr, value);
 419                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 420             }
 421             get
 422             {
 423                 float ret = NDalicPINVOKE.Animation_GetProgressNotification(swigCPtr);
 424                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 425                 return ret;
 426             }
 427         }
 428
 429         /// <summary>
 430         /// Animates a property value by a relative amount.<br>
 431         /// </summary>
 432         /// <param name="target">The target object to animate</param>
 433         /// <param name="property">The target property to animate</param>
 434         /// <param name="relativeValue">The property value will change by this amount</param>
 435         /// <param name="alphaFunction">The alpha function to apply</param>
 436         public void AnimateBy(View target, string property, object relativeValue, AlphaFunction alphaFunction = null)
 437         {
 438             string _str1 = property.Substring(0, 1);
 439             string _str2 = property.Substring(1);
 440             string _str = _str1.ToLower() + _str2;
 441
 442             Property _prop = new Property(target, _str);
 443             if (_prop.propertyIndex == Property.INVALID_INDEX)
 444             {
 445                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 446             }
 447
 448             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 449             if(propertyType.Equals(PropertyType.Float))
 450             {
 451                 System.Type type = relativeValue.GetType();
 452                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 453                 {
 454                     int num = (int)relativeValue;
 455                     relativeValue = (float)num;
 456                 }
 457             }
 458
 459             PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
 460
 461             if (alphaFunction != null)
 462             {
 463                 AnimateBy(_prop, val, alphaFunction);
 464             }
 465             else
 466             {
 467                 AnimateBy(_prop, val);
 468             }
 469         }
 470
 471         /// <summary>
 472         /// Animates a property value by a relative amount.<br>
 473         /// </summary>
 474         /// <param name="target">The target object to animate</param>
 475         /// <param name="property">The target property to animate</param>
 476         /// <param name="relativeValue">The property value will change by this amount</param>
 477         /// <param name="startTime">Start time of animation</param>
 478         /// <param name="endTime">End time of animation</param>
 479         /// <param name="alphaFunction">The alpha function to apply</param>
 480         public void AnimateBy(View target, string property, object relativeValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
 481         {
 482             string _str1 = property.Substring(0, 1);
 483             string _str2 = property.Substring(1);
 484             string _str = _str1.ToLower() + _str2;
 485
 486             Property _prop = new Property(target, _str);
 487             if (_prop.propertyIndex == Property.INVALID_INDEX)
 488             {
 489                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 490             }
 491
 492             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 493             if(propertyType.Equals(PropertyType.Float))
 494             {
 495                 System.Type type = relativeValue.GetType();
 496                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 497                 {
 498                     int num = (int)relativeValue;
 499                     relativeValue = (float)num;
 500                 }
 501             }
 502
 503             PropertyValue val = PropertyValue.CreateFromObject(relativeValue);
 504
 505             if (alphaFunction != null)
 506             {
 507                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 508                 AnimateBy(_prop, val, alphaFunction, time);
 509             }
 510             else
 511             {
 512                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 513                 AnimateBy(_prop, val, time);
 514             }
 515         }
 516
 517         /// <summary>
 518         /// Animates a property to a destination value.<br>
 519         /// </summary>
 520         /// <param name="target">The target object to animate</param>
 521         /// <param name="property">The target property to animate</param>
 522         /// <param name="destinationValue">The destination value</param>
 523         /// <param name="alphaFunction">The alpha function to apply</param>
 524         public void AnimateTo(View target, string property, object destinationValue, AlphaFunction alphaFunction = null)
 525         {
 526             string _str1 = property.Substring(0, 1);
 527             string _str2 = property.Substring(1);
 528             string _str = _str1.ToLower() + _str2;
 529
 530             Property _prop = new Property(target, _str);
 531             if (_prop.propertyIndex == Property.INVALID_INDEX)
 532             {
 533                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 534             }
 535
 536             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 537             if(propertyType.Equals(PropertyType.Float))
 538             {
 539                 System.Type type = destinationValue.GetType();
 540                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 541                 {
 542                     int num = (int)destinationValue;
 543                     destinationValue = (float)num;
 544                 }
 545             }
 546
 547             PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 548
 549             if (alphaFunction != null)
 550             {
 551                 AnimateTo(_prop, val, alphaFunction);
 552             }
 553             else
 554             {
 555                 AnimateTo(_prop, val);
 556             }
 557         }
 558
 559         /// <summary>
 560         /// Animates a property to a destination value.<br>
 561         /// </summary>
 562         /// <param name="target">The target object to animate</param>
 563         /// <param name="property">The target property to animate</param>
 564         /// <param name="destinationValue">The destination value</param>
 565         /// <param name="alphaFunction">The alpha function to apply</param>
 566         /// <param name="startTime">Start time of animation</param>
 567         /// <param name="endTime">End time of animation</param>
 568         /// <param name="alphaFunction">The alpha function to apply</param>
 569         public void AnimateTo(View target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
 570         {
 571             string _str1 = property.Substring(0, 1);
 572             string _str2 = property.Substring(1);
 573             string _str = _str1.ToLower() + _str2;
 574
 575             Property _prop = new Property(target, _str);
 576             if (_prop.propertyIndex == Property.INVALID_INDEX)
 577             {
 578                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 579             }
 580
 581             PropertyType propertyType = target.GetPropertyType(_prop.propertyIndex);
 582             if(propertyType.Equals(PropertyType.Float))
 583             {
 584                 System.Type type = destinationValue.GetType();
 585                 if (type.Equals(typeof(System.Int32)) || type.Equals(typeof(int)))
 586                 {
 587                     int num = (int)destinationValue;
 588                     destinationValue = (float)num;
 589                 }
 590             }
 591
 592             PropertyValue val = PropertyValue.CreateFromObject(destinationValue);
 593
 594             if (alphaFunction != null)
 595             {
 596                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 597                 AnimateTo(_prop, val, alphaFunction, time);
 598             }
 599             else
 600             {
 601                 Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 602                 AnimateTo(_prop, val, time);
 603             }
 604         }
 605
 606         /// <summary>
 607         /// Animates a property between keyframes.
 608         /// </summary>
 609         /// <param name="target">The target object to animate</param>
 610         /// <param name="property">The target property to animate</param>
 611         /// <param name="keyFrames">The set of time/value pairs between which to animate</param>
 612         /// <param name="interpolation">The method used to interpolate between values</param>
 613         /// <param name="alphaFunction">The alpha function to apply</param>
 614         public void AnimateBetween(View target, string property, KeyFrames keyFrames, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
 615         {
 616             string _str1 = property.Substring(0, 1);
 617             string _str2 = property.Substring(1);
 618             string _str = _str1.ToLower() + _str2;
 619
 620             Property _prop = new Property(target, _str);
 621             if (_prop.propertyIndex == Property.INVALID_INDEX)
 622             {
 623                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 624             }
 625
 626             if (alphaFunction != null)
 627             {
 628                 AnimateBetween(_prop, keyFrames, alphaFunction, interpolation);
 629             }
 630             else
 631             {
 632                 AnimateBetween(_prop, keyFrames, interpolation);
 633             }
 634         }
 635
 636
 637         /// <summary>
 638         /// Animates a property between keyframes.
 639         /// </summary>
 640         /// <param name="target">The target object to animate</param>
 641         /// <param name="property">The target property to animate</param>
 642         /// <param name="keyFrames">The set of time/value pairs between which to animate</param>
 643         /// <param name="startTime">Start time of animation in milli seconds</param>
 644         /// <param name="endTime">End time of animation in milli seconds</param>
 645         /// <param name="interpolation">The method used to interpolate between values</param>
 646         /// <param name="alphaFunction">The alpha function to apply</param>
 647         public void AnimateBetween(View target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
 648         {
 649             string _str1 = property.Substring(0, 1);
 650             string _str2 = property.Substring(1);
 651             string _str = _str1.ToLower() + _str2;
 652
 653             Property _prop = new Property(target, _str);
 654             if (_prop.propertyIndex == Property.INVALID_INDEX)
 655             {
 656                 throw new System.ArgumentException("second argument string property is invalid parameter!");
 657             }
 658
 659             Tizen.NUI.TimePeriod time = new Tizen.NUI.TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 660             if (alphaFunction != null)
 661             {
 662                 AnimateBetween(_prop, keyFrames, alphaFunction, time, interpolation);
 663             }
 664             else
 665             {
 666                 AnimateBetween(_prop, keyFrames, time, interpolation);
 667             }
 668         }
 669
 670         /// <summary>
 671         /// Animates an view's position and orientation through a predefined path.<br>
 672         /// The view will rotate to orient the supplied forward vector with the path's tangent.<br>
 673         /// If forward is the zero vector then no rotation will happen.<br>
 674         /// </summary>
 675         /// <param name="view">The view to animate</param>
 676         /// <param name="path">It defines position and orientation</param>
 677         /// <param name="forward">The vector (in local space coordinate system) that will be oriented with the path's tangent direction</param>
 678         /// <param name="alphaFunction">The alpha function to apply</param>
 679         public void AnimatePath(View view, Path path, Vector3 forward, AlphaFunction alphaFunction = null)
 680         {
 681             if (alphaFunction == null)
 682             {
 683                 Animate(view, path, forward);
 684             }
 685             else
 686             {
 687                 Animate(view, path, forward, alphaFunction);
 688             }
 689         }
 690
 691         /// <summary>
 692         /// Animates an view's position and orientation through a predefined path.<br>
 693         /// The view will rotate to orient the supplied forward vector with the path's tangent.<br>
 694         /// If forward is the zero vector then no rotation will happen.<br>
 695         /// </summary>
 696         /// <param name="view">The view to animate</param>
 697         /// <param name="path">It defines position and orientation</param>
 698         /// <param name="forward">The vector (in local space coordinate system) that will be oriented with the path's tangent direction</param>
 699         /// <param name="startTime">Start time of animation</param>
 700         /// <param name="endTime">End time of animation</param>
 701         /// <param name="alphaFunction">The alpha function to apply</param>
 702         public void AnimatePath(View view, Path path, Vector3 forward, int startTime, int endTime, AlphaFunction alphaFunction = null)
 703         {
 704             TimePeriod time = new TimePeriod(MilliSecondsToSeconds(startTime), MilliSecondsToSeconds(endTime - startTime));
 705             if (alphaFunction == null)
 706             {
 707                 Animate(view, path, forward, time);
 708             }
 709             else
 710             {
 711                 Animate(view, path, forward, alphaFunction, time);
 712             }
 713         }
 714
 715         /// <summary>
 716         /// Creates an initialized Animation.<br>
 717         /// The animation will not loop.<br>
 718         /// The default end action is "Cancel".<br>
 719         /// The default alpha function is linear.<br>
 720         /// </summary>
 721         public Animation() : this(NDalicPINVOKE.Animation_New(0.0f), true)
 722         {
 723             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 724         }
 725
 726         internal Animation(float durationSeconds) : this(NDalicPINVOKE.Animation_New(durationSeconds), true)
 727         {
 728             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 729
 730         }
 731
 732         /// <summary>
 733         /// Downcasts a handle to Animation handle.<br>
 734         /// If handle points to an Animation object, the downcast produces valid handle.<br>
 735         /// If not, the returned handle is left uninitialized.<br>
 736         /// </summary>
 737         /// <param name="handle">Handle to an object</param>
 738         /// <returns>Handle to an Animation object or an uninitialized handle</returns>
 739         public static Animation DownCast(BaseHandle handle)
 740         {
 741             Animation ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as Animation;
 742             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 743             return ret;
 744         }
 745
 746         internal Animation(Animation handle) : this(NDalicPINVOKE.new_Animation__SWIG_1(Animation.getCPtr(handle)), true)
 747         {
 748             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 749         }
 750
 751         internal Animation Assign(Animation rhs)
 752         {
 753             Animation ret = new Animation(NDalicPINVOKE.Animation_Assign(swigCPtr, Animation.getCPtr(rhs)), false);
 754             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 755             return ret;
 756         }
 757
 758         internal void SetDuration(float seconds)
 759         {
 760             NDalicPINVOKE.Animation_SetDuration(swigCPtr, seconds);
 761             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 762         }
 763
 764         internal float GetDuration()
 765         {
 766             float ret = NDalicPINVOKE.Animation_GetDuration(swigCPtr);
 767             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 768             return ret;
 769         }
 770
 771         internal void SetLooping(bool looping)
 772         {
 773             NDalicPINVOKE.Animation_SetLooping(swigCPtr, looping);
 774             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 775         }
 776
 777         internal void SetLoopCount(int count)
 778         {
 779             NDalicPINVOKE.Animation_SetLoopCount(swigCPtr, count);
 780             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 781         }
 782
 783         internal int GetLoopCount()
 784         {
 785             int ret = NDalicPINVOKE.Animation_GetLoopCount(swigCPtr);
 786             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 787             return ret;
 788         }
 789
 790         internal int GetCurrentLoop()
 791         {
 792             int ret = NDalicPINVOKE.Animation_GetCurrentLoop(swigCPtr);
 793             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 794             return ret;
 795         }
 796
 797         internal bool IsLooping()
 798         {
 799             bool ret = NDalicPINVOKE.Animation_IsLooping(swigCPtr);
 800             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 801             return ret;
 802         }
 803
 804         internal void SetEndAction(Animation.EndActions action)
 805         {
 806             NDalicPINVOKE.Animation_SetEndAction(swigCPtr, (int)action);
 807             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 808         }
 809
 810         internal Animation.EndActions GetEndAction()
 811         {
 812             Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetEndAction(swigCPtr);
 813             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 814             return ret;
 815         }
 816
 817         internal void SetDisconnectAction(Animation.EndActions disconnectAction)
 818         {
 819             NDalicPINVOKE.Animation_SetDisconnectAction(swigCPtr, (int)disconnectAction);
 820             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 821         }
 822
 823         internal Animation.EndActions GetDisconnectAction()
 824         {
 825             Animation.EndActions ret = (Animation.EndActions)NDalicPINVOKE.Animation_GetDisconnectAction(swigCPtr);
 826             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 827             return ret;
 828         }
 829
 830         internal void SetDefaultAlphaFunction(AlphaFunction alpha)
 831         {
 832             NDalicPINVOKE.Animation_SetDefaultAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
 833             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 834         }
 835
 836         internal AlphaFunction GetDefaultAlphaFunction()
 837         {
 838             AlphaFunction ret = new AlphaFunction(NDalicPINVOKE.Animation_GetDefaultAlphaFunction(swigCPtr), true);
 839             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 840             return ret;
 841         }
 842
 843         internal void SetCurrentProgress(float progress)
 844         {
 845             NDalicPINVOKE.Animation_SetCurrentProgress(swigCPtr, progress);
 846             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 847         }
 848
 849         internal float GetCurrentProgress()
 850         {
 851             float ret = NDalicPINVOKE.Animation_GetCurrentProgress(swigCPtr);
 852             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 853             return ret;
 854         }
 855
 856         internal void SetSpeedFactor(float factor)
 857         {
 858             NDalicPINVOKE.Animation_SetSpeedFactor(swigCPtr, factor);
 859             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 860         }
 861
 862         internal float GetSpeedFactor()
 863         {
 864             float ret = NDalicPINVOKE.Animation_GetSpeedFactor(swigCPtr);
 865             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 866             return ret;
 867         }
 868
 869         internal void SetPlayRange(Vector2 range)
 870         {
 871             NDalicPINVOKE.Animation_SetPlayRange(swigCPtr, Vector2.getCPtr(range));
 872             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 873         }
 874
 875         internal Vector2 GetPlayRange()
 876         {
 877             Vector2 ret = new Vector2(NDalicPINVOKE.Animation_GetPlayRange(swigCPtr), true);
 878             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 879             return ret;
 880         }
 881
 882         /// <summary>
 883         /// Plays the animation.
 884         /// </summary>
 885         public void Play()
 886         {
 887             NDalicPINVOKE.Animation_Play(swigCPtr);
 888             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 889 #if DISABLE_ANIMATION
 890             Stop(EndActions.StopFinal);
 891 #endif
 892         }
 893
 894         /// <summary>
 895         /// Plays the animation from a given point.<br>
 896         /// The progress must be in the 0-1 interval or in the play range interval if defined,
 897         /// otherwise, it will be ignored.<br>
 898         /// </summary>
 899         /// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing</param>
 900         public void PlayFrom(float progress)
 901         {
 902             NDalicPINVOKE.Animation_PlayFrom(swigCPtr, progress);
 903             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 904         }
 905
 906         /// <summary>
 907         /// Play the animation after a given delay time.<br/>
 908         /// The delay time is not included in the looping time.<br/>
 909         /// When the delay time is negative value, it would treat as play immediately.<br/>
 910         /// </summary>
 911         /// <param name="delayMiliSeconds">The delay time</param>
 912         public void PlayAfter(int delayMiliSeconds)
 913         {
 914             NDalicPINVOKE.Animation_PlayAfter(swigCPtr, MilliSecondsToSeconds(delayMiliSeconds));
 915             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 916         }
 917
 918         /// <summary>
 919         /// Pauses the animation.
 920         /// </summary>
 921         public void Pause()
 922         {
 923             NDalicPINVOKE.Animation_Pause(swigCPtr);
 924             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 925         }
 926
 927         internal Animation.States GetState()
 928         {
 929             Animation.States ret = (Animation.States)NDalicPINVOKE.Animation_GetState(swigCPtr);
 930             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 931             return ret;
 932         }
 933
 934         /// <summary>
 935         /// Stops the animation.
 936         /// </summary>
 937         public void Stop()
 938         {
 939             NDalicPINVOKE.Animation_Stop(swigCPtr);
 940             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 941         }
 942
 943         /// <summary>
 944         /// Clears the animation.<br>
 945         /// This disconnects any objects that were being animated, effectively stopping the animation.<br>
 946         /// </summary>
 947         public void Clear()
 948         {
 949             NDalicPINVOKE.Animation_Clear(swigCPtr);
 950             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 951         }
 952
 953         internal AnimationSignal FinishedSignal()
 954         {
 955             AnimationSignal ret = new AnimationSignal(NDalicPINVOKE.Animation_FinishedSignal(swigCPtr), false);
 956             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 957             return ret;
 958         }
 959
 960         internal AnimationSignal ProgressReachedSignal()
 961         {
 962             AnimationSignal ret = new AnimationSignal(NDalicPINVOKE.Animation_ProgressReachedSignal(swigCPtr), false);
 963             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 964             return ret;
 965         }
 966
 967         internal void AnimateBy(Property target, PropertyValue relativeValue)
 968         {
 969             NDalicPINVOKE.Animation_AnimateBy__SWIG_0(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue));
 970             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 971         }
 972
 973         internal void AnimateBy(Property target, PropertyValue relativeValue, AlphaFunction alpha)
 974         {
 975             NDalicPINVOKE.Animation_AnimateBy__SWIG_1(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha));
 976             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 977         }
 978
 979         internal void AnimateBy(Property target, PropertyValue relativeValue, TimePeriod period)
 980         {
 981             NDalicPINVOKE.Animation_AnimateBy__SWIG_2(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), TimePeriod.getCPtr(period));
 982             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 983         }
 984
 985         internal void AnimateBy(Property target, PropertyValue relativeValue, AlphaFunction alpha, TimePeriod period)
 986         {
 987             NDalicPINVOKE.Animation_AnimateBy__SWIG_3(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(relativeValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
 988             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 989         }
 990
 991         internal void AnimateTo(Property target, PropertyValue destinationValue)
 992         {
 993             NDalicPINVOKE.Animation_AnimateTo__SWIG_0(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue));
 994             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 995         }
 996
 997         internal void AnimateTo(Property target, PropertyValue destinationValue, AlphaFunction alpha)
 998         {
 999             NDalicPINVOKE.Animation_AnimateTo__SWIG_1(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha));
1000             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1001         }
1002
1003         internal void AnimateTo(Property target, PropertyValue destinationValue, TimePeriod period)
1004         {
1005             NDalicPINVOKE.Animation_AnimateTo__SWIG_2(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), TimePeriod.getCPtr(period));
1006             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1007         }
1008
1009         internal void AnimateTo(Property target, PropertyValue destinationValue, AlphaFunction alpha, TimePeriod period)
1010         {
1011             NDalicPINVOKE.Animation_AnimateTo__SWIG_3(swigCPtr, Property.getCPtr(target), PropertyValue.getCPtr(destinationValue), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1012             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1013         }
1014
1015         internal void AnimateBetween(Property target, KeyFrames keyFrames)
1016         {
1017             NDalicPINVOKE.Animation_AnimateBetween__SWIG_0(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames));
1018             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1019         }
1020
1021         internal void AnimateBetween(Property target, KeyFrames keyFrames, Animation.Interpolation interpolation)
1022         {
1023             NDalicPINVOKE.Animation_AnimateBetween__SWIG_1(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), (int)interpolation);
1024             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1025         }
1026
1027         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha)
1028         {
1029             NDalicPINVOKE.Animation_AnimateBetween__SWIG_2(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha));
1030             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1031         }
1032
1033         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, Animation.Interpolation interpolation)
1034         {
1035             NDalicPINVOKE.Animation_AnimateBetween__SWIG_3(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), (int)interpolation);
1036             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1037         }
1038
1039         internal void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period)
1040         {
1041             NDalicPINVOKE.Animation_AnimateBetween__SWIG_4(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period));
1042             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1043         }
1044
1045         internal void AnimateBetween(Property target, KeyFrames keyFrames, TimePeriod period, Animation.Interpolation interpolation)
1046         {
1047             NDalicPINVOKE.Animation_AnimateBetween__SWIG_5(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), TimePeriod.getCPtr(period), (int)interpolation);
1048             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1049         }
1050
1051         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period)
1052         {
1053             NDalicPINVOKE.Animation_AnimateBetween__SWIG_6(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1054             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1055         }
1056
1057         internal void AnimateBetween(Property target, KeyFrames keyFrames, AlphaFunction alpha, TimePeriod period, Animation.Interpolation interpolation)
1058         {
1059             NDalicPINVOKE.Animation_AnimateBetween__SWIG_7(swigCPtr, Property.getCPtr(target), KeyFrames.getCPtr(keyFrames), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period), (int)interpolation);
1060             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1061         }
1062
1063         internal void Animate(View view, Path path, Vector3 forward)
1064         {
1065             NDalicPINVOKE.Animation_Animate__SWIG_0(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward));
1066             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1067         }
1068
1069         internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha)
1070         {
1071             NDalicPINVOKE.Animation_Animate__SWIG_1(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha));
1072             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1073         }
1074
1075         internal void Animate(View view, Path path, Vector3 forward, TimePeriod period)
1076         {
1077             NDalicPINVOKE.Animation_Animate__SWIG_2(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), TimePeriod.getCPtr(period));
1078             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1079         }
1080
1081         internal void Animate(View view, Path path, Vector3 forward, AlphaFunction alpha, TimePeriod period)
1082         {
1083             NDalicPINVOKE.Animation_Animate__SWIG_3(swigCPtr, View.getCPtr(view), Path.getCPtr(path), Vector3.getCPtr(forward), AlphaFunction.getCPtr(alpha), TimePeriod.getCPtr(period));
1084             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1085         }
1086
1087         internal void Show(View view, float delaySeconds)
1088         {
1089             NDalicPINVOKE.Animation_Show(swigCPtr, View.getCPtr(view), delaySeconds);
1090             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1091         }
1092
1093         internal void Hide(View view, float delaySeconds)
1094         {
1095             NDalicPINVOKE.Animation_Hide(swigCPtr, View.getCPtr(view), delaySeconds);
1096             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1097         }
1098
1099         /// <summary>
1100         /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.
1101         /// </summary>
1102         public enum EndActions
1103         {
1104             /// <summary>
1105             /// When the animation ends, the animated property values are saved.
1106             /// </summary>
1107             Cancel,
1108             /// <summary>
1109             /// When the animation ends, the animated property values are forgotten.
1110             /// </summary>
1111             Discard,
1112             /// <summary>
1113             /// If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.
1114             /// </summary>
1115             StopFinal
1116         }
1117
1118         /// <summary>
1119         /// Enumeration for what interpolation method to use on key-frame animations.
1120         /// </summary>
1121         public enum Interpolation
1122         {
1123             /// <summary>
1124             /// Values in between key frames are interpolated using a linear polynomial. (Default)
1125             /// </summary>
1126             Linear,
1127             /// <summary>
1128             /// Values in between key frames are interpolated using a cubic polynomial.
1129             /// </summary>
1130             Cubic
1131         }
1132
1133         /// <summary>
1134         /// Enumeration for what state the animation is in.
1135         /// </summary>
1136         /// <remarks>Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.</remarks>
1137         public enum States
1138         {
1139             /// <summary>
1140             /// Animation has stopped
1141             /// </summary>
1142             Stopped,
1143             /// <summary>
1144             /// The animation is playing
1145             /// </summary>
1146             Playing,
1147             /// <summary>
1148             /// The animation is paused
1149             /// </summary>
1150             Paused
1151         }
1152
1153     }
1154
1155 }