xartigas pushed a commit to branch master.

http://git.enlightenment.org/core/efl.git/commit/?id=dc5ffbb8660db8f93ebf698802a56b31daeaf8b9

commit dc5ffbb8660db8f93ebf698802a56b31daeaf8b9
Author: Xavi Artigas <[email protected]>
Date:   Mon Nov 4 13:06:41 2019 +0100

    docs: Polish Efl.Canvas.Animation_*
    
    Summary:
    These docs were lacking a lot of detail.
    
    Depends on D10562
    
    Reviewers: bu5hm4n, cedric, zmike, Jaehyun_Cho
    
    Reviewed By: cedric
    
    Subscribers: #reviewers, #committers
    
    Tags: #efl
    
    Differential Revision: https://phab.enlightenment.org/D10565
---
 src/lib/evas/canvas/efl_canvas_animation_alpha.eo  | 15 +++++---
 src/lib/evas/canvas/efl_canvas_animation_rotate.eo | 40 +++++++++++++++------
 src/lib/evas/canvas/efl_canvas_animation_scale.eo  | 41 ++++++++++++++++------
 .../evas/canvas/efl_canvas_animation_translate.eo  | 28 +++++++++++----
 4 files changed, 91 insertions(+), 33 deletions(-)

diff --git a/src/lib/evas/canvas/efl_canvas_animation_alpha.eo 
b/src/lib/evas/canvas/efl_canvas_animation_alpha.eo
index 1ff9720c3e..d76a80c1a0 100644
--- a/src/lib/evas/canvas/efl_canvas_animation_alpha.eo
+++ b/src/lib/evas/canvas/efl_canvas_animation_alpha.eo
@@ -1,18 +1,25 @@
 class @beta Efl.Canvas.Animation_Alpha extends Efl.Canvas.Animation
 {
-   [[Efl alpha animation class]]
+   [[Animated alpha blending effect.
+
+     The @Efl.Canvas.Object will have its alpha (transparency) value 
multiplied by
+     this animation.
+     This can be used to create fade-in and fade-out transitions, for example.
+   ]]
    c_prefix: efl_animation_alpha;
    data: Efl_Canvas_Animation_Alpha_Data;
    methods {
       @property alpha {
-         [[Alpha property]]
+         [[Alpha range to animate. $[0.0] means the object is transparent and 
$[1.0] means
+           the object is opaque.
+         ]]
          set {
          }
          get {
          }
          values {
-            from_alpha: double; [[Alpha value when animation starts]]
-            to_alpha: double; [[Alpha value when animation ends]]
+            from_alpha: double; [[Initial alpha value.]]
+            to_alpha: double; [[Ending alpha value.]]
          }
       }
    }
diff --git a/src/lib/evas/canvas/efl_canvas_animation_rotate.eo 
b/src/lib/evas/canvas/efl_canvas_animation_rotate.eo
index 3c1d8af086..c7463f8824 100644
--- a/src/lib/evas/canvas/efl_canvas_animation_rotate.eo
+++ b/src/lib/evas/canvas/efl_canvas_animation_rotate.eo
@@ -1,33 +1,51 @@
 class @beta Efl.Canvas.Animation_Rotate extends Efl.Canvas.Animation
 {
-   [[Efl rotate animation class]]
+   [[Animated rotation effect.
+
+     The @Efl.Canvas.Object will rotate around a pivot point from one degree 
to another.
+     Coordinates for the pivot point can be relative to another object or 
absolute
+     (relative to the containing canvas).
+
+     Note: Changing an object's position using @Efl.Gfx.Entity.position while 
this
+     animation is running might lead to unexpected results.
+   ]]
    c_prefix: efl_animation_rotate;
    data: Efl_Canvas_Animation_Rotate_Data;
    methods {
       @property rotate {
-         [[Rotate property]]
+         [[Degree range to animate and pivot object.
+           The object will rotate from $from_degree to $to_degree around the 
pivot point.
+           All of the object's vertices (i.e. the corners, if it's a 
rectangular object)
+           will be rotated by these degrees, relative to the pivot point 
inside the pivot object.
+           The pivot point is another object $pivot plus an additional offset 
$center_point.
+         ]]
          set {
          }
          get {
          }
          values {
-            from_degree: double; [[Rotation degree when animation starts]]
-            to_degree: double; [[Rotation degree when animation ends]]
-            pivot: Efl.Canvas.Object; [[Pivot object for the center point.
-                                        If the pivot object is $NULL, then the 
object is rotated on itself.]]
-            center_point : Eina.Vector2; [[Relative coordinate of the center 
point.]]
+            from_degree: double; [[Initial rotation (from 0 to 360). 0 means 
no rotation.]]
+            to_degree: double; [[Ending rotation (from 0 to 360). 0 means no 
rotation.]]
+            pivot: Efl.Canvas.Object; [[Object to use as pivot. $NULL means 
the animated object itself.]]
+            center_point: Eina.Vector2; [[Position in pixels of the pivot 
point inside the pivot object.
+                                         $[(0,0)] means the upper-left 
corner.]]
          }
       }
       @property rotate_absolute {
-         [[Rotate absolute property]]
+         [[Degree range to animate and absolute pivot point.
+           The object will rotate from $from_degree to $to_degree around the 
pivot point.
+           All of the object's vertices (i.e. the corners, if it's a 
rectangular object)
+           will be rotated by these degrees, relative to an absolute pivot 
point.
+           The pivot point is relative to the canvas.
+         ]]
          set {
          }
          get {
          }
          values {
-            from_degree: double; [[Rotation degree when animation starts]]
-            to_degree: double; [[Rotation degree when animation ends]]
-            center_pointer : Eina.Position2D; [[absolute coordinate of the 
center point.]]
+            from_degree: double; [[Initial rotation (from 0 to 360). 0 means 
no rotation.]]
+            to_degree: double; [[Ending rotation (from 0 to 360). 0 means no 
rotation.]]
+            pivot_point : Eina.Position2D; [[Position of the pivot point 
relative to the canvas.]]
          }
       }
    }
diff --git a/src/lib/evas/canvas/efl_canvas_animation_scale.eo 
b/src/lib/evas/canvas/efl_canvas_animation_scale.eo
index b35c5d819b..23f9dea0b0 100644
--- a/src/lib/evas/canvas/efl_canvas_animation_scale.eo
+++ b/src/lib/evas/canvas/efl_canvas_animation_scale.eo
@@ -1,33 +1,52 @@
 class @beta Efl.Canvas.Animation_Scale extends Efl.Canvas.Animation
 {
-   [[Efl scale animation class]]
+   [[Animated scaling effect.
+
+     The @Efl.Canvas.Object will have its size and position changed due to a 
scaling
+     operation around a specified pivot point.
+     Coordinates for the pivot point can be relative to the object or absolute
+     (relative to the containing canvas).
+
+     Note: Changing an object's geometry using @Efl.Gfx.Entity.position or 
@Efl.Gfx.Entity.size
+     while this animation is running might lead to unexpected results.
+   ]]
    c_prefix: efl_animation_scale;
    data: Efl_Canvas_Animation_Scale_Data;
    methods {
       @property scale {
-         [[Scale property]]
+         [[Scale range and pivot object.
+           The object's scale will change from $from_scale to $to_scale.
+           All of the object's vertices (i.e. the corners, if it's a 
rectangular object)
+           will be multiplied by this scale, relative to the pivot point 
inside the pivot object.
+           The pivot point is another object $pivot plus an additional offset 
$center_point.
+         ]]
          set {
          }
          get {
          }
          values {
-            from_scale : Eina.Vector2; [[Scale factor  when animation starts]]
-            to_scale : Eina.Vector2; [[Scale factor when animation ends]]
-            pivot: Efl.Canvas.Object; [[Pivot object for the center point. If 
the pivot object is $NULL, then the object
-                                        is scaled on itself.]]
-            pivot_pos : Eina.Vector2; [[Relative coordinates of the center 
point. 0.0,0.0 is upper left.]]
+            from_scale: Eina.Vector2; [[Initial scale value.]]
+            to_scale: Eina.Vector2; [[Ending scale value.]]
+            pivot: Efl.Canvas.Object; [[Object to use as pivot. $NULL means 
the animated object itself.]]
+            center_point: Eina.Vector2; [[Position in pixels of the pivot 
point inside the pivot object.
+                                          $[(0,0)] means the upper-left 
corner.]]
          }
       }
       @property scale_absolute {
-         [[Scale absolute property]]
+         [[Scale range and pivot position, relative to the canvas.
+           The object's scale will change from $from_scale to $to_scale.
+           All of the object's vertices (i.e. the corners, if it's a 
rectangular object)
+           will be multiplied by this scale, relative to the pivot point.
+           The pivot point is relative to the canvas.
+         ]]
          set {
          }
          get {
          }
          values {
-            from_scale : Eina.Vector2; [[Scale factor  when animation starts]]
-            to_scale : Eina.Vector2; [[Scale factor when animation ends]]
-            pos : Eina.Position2D; [[Absolut coordinates in canvas space]]
+            from_scale: Eina.Vector2; [[Initial scale value.]]
+            to_scale: Eina.Vector2; [[Ending scale value.]]
+            pivot_point: Eina.Position2D; [[Position of the pivot point 
relative to the canvas.]]
          }
       }
    }
diff --git a/src/lib/evas/canvas/efl_canvas_animation_translate.eo 
b/src/lib/evas/canvas/efl_canvas_animation_translate.eo
index e4b2678679..ed06dd567c 100644
--- a/src/lib/evas/canvas/efl_canvas_animation_translate.eo
+++ b/src/lib/evas/canvas/efl_canvas_animation_translate.eo
@@ -1,29 +1,43 @@
 class @beta Efl.Canvas.Animation_Translate extends Efl.Canvas.Animation
 {
-   [[Efl translate animation class]]
+   [[Animated translation effect.
+
+     The @Efl.Canvas.Object will move from one point to another.
+     Coordinates for the origin and destination points can be relative to the 
object
+     or absolute (relative to the containing canvas).
+
+     Note: Changing an object's position using @Efl.Gfx.Entity.position while 
this
+     animation is running might lead to unexpected results.
+   ]]
    c_prefix: efl_animation_translate;
    data: Efl_Canvas_Animation_Translate_Data;
    methods {
       @property translate {
-         [[Translate property]]
+         [[Translation vector, relative to the starting position of the object.
+           So, for example, if $from is $[(0,0)], the object will move from its
+           current position to $to.
+         ]]
          set {
          }
          get {
          }
          values {
-            from : Eina.Position2D; [[Position moved when animation starts.]]
-            to : Eina.Position2D; [[Position moved when animation ends.]]
+            from : Eina.Position2D; [[Relative initial position.]]
+            to : Eina.Position2D; [[Relative ending position.]]
          }
       }
       @property translate_absolute {
-         [[Translate absolute property]]
+         [[Translation vector, relative to the canvas.
+           So, for example, if $from is $[(0,0)], the object will always start 
from the
+           origin of the canvas, regardless of the current object position.
+         ]]
          set {
          }
          get {
          }
          values {
-            from : Eina.Position2D; [[The position where the animation 
starts.]]
-            to : Eina.Position2D; [[The position where the animation stops.]]
+            from : Eina.Position2D; [[Absolute initial position.]]
+            to : Eina.Position2D; [[Absolute ending position.]]
          }
       }
    }

-- 


Reply via email to