X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;ds=sidebyside;f=src%2FTizen.NUI%2Fsrc%2Fpublic%2FSize2D.cs;h=9f30751eda3e77c04a8e842a410640c37c5f00c3;hb=5e1c35c38b2bc29eebc484679f7de727b636f744;hp=13006b47193f641be095927584df93867ca59a31;hpb=f4f1f421c081e4007d3e1d52211ed3db72707ecd;p=platform%2Fcore%2Fcsapi%2Ftizenfx.git

diff --git a/src/Tizen.NUI/src/public/Size2D.cs b/src/Tizen.NUI/src/public/Size2D.cs
index 13006b4..9f30751 100755
--- a/src/Tizen.NUI/src/public/Size2D.cs
+++ b/src/Tizen.NUI/src/public/Size2D.cs
@@ -19,7 +19,7 @@ namespace Tizen.NUI
 {
 
     /// <summary>
-    /// A two dimensional size
+    /// A two-dimensional size.
     /// </summary>
     public class Size2D : global::System.IDisposable
     {
@@ -52,7 +52,7 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Dispose
+        /// Dispose.
         /// </summary>
         public void Dispose()
         {
@@ -104,54 +104,54 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Addition operator for A+B
+        /// The addition operator for A+B.
         /// </summary>
-        /// <param name="arg1">Size, A</param>
-        /// <param name="arg2">Size to assign, B</param>
-        /// <returns>A Size containing the result of the addition</returns>
+        /// <param name="arg1">Size A.</param>
+        /// <param name="arg2">Size to assign B.</param>
+        /// <returns>A size containing the result of the addition.</returns>
         public static Size2D operator +(Size2D arg1, Size2D arg2)
         {
             return arg1.Add(arg2);
         }
 
         /// <summary>
-        /// Subtraction operator for A-B
+        /// The subtraction operator for A-B.
         /// </summary>
-        /// <param name="arg1">Size, A</param>
-        /// <param name="arg2">Size to subtract, B</param>
-        /// <returns>A Size containing the result of the subtraction</returns>
+        /// <param name="arg1">Size A.</param>
+        /// <param name="arg2">Size to subtract B.</param>
+        /// <returns>A size containing the result of the subtraction.</returns>
         public static Size2D operator -(Size2D arg1, Size2D arg2)
         {
             return arg1.Subtract(arg2);
         }
 
         /// <summary>
-        /// Unary negation operator.
+        /// The unary negation operator.
         /// </summary>
-        /// <param name="arg1">Size for unary negation</param>
-        /// <returns>A Size containg the negation</returns>
+        /// <param name="arg1">Size for unary negation.</param>
+        /// <returns>A size containing the negation.</returns>
         public static Size2D operator -(Size2D arg1)
         {
             return arg1.Subtract();
         }
 
         /// <summary>
-        /// Multiplication operator.
+        /// The multiplication operator.
         /// </summary>
-        /// <param name="arg1">Size for multiplication</param>
-        /// <param name="arg2">The Size to multipl</param>
-        /// <returns>A Size containing the result of the multiplication</returns>
+        /// <param name="arg1">Size for multiplication.</param>
+        /// <param name="arg2">Size to multiply.</param>
+        /// <returns>A size containing the result of the multiplication.</returns>
         public static Size2D operator *(Size2D arg1, Size2D arg2)
         {
             return arg1.Multiply(arg2);
         }
 
         /// <summary>
-        /// Multiplication operator.
+        /// The multiplication operator.
         /// </summary>
         /// <param name="arg1">Size for multiplication</param>
-        /// <param name="arg2">The int value to scale the Size</param>
-        /// <returns>A Size containing the result of the scaling</returns>
+        /// <param name="arg2">The integer value to scale the size.</param>
+        /// <returns>A size containing the result of the scaling.</returns>
 
         public static Size2D operator *(Size2D arg1, int arg2)
         {
@@ -159,32 +159,32 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Division operator.
+        /// The division operator.
         /// </summary>
-        /// <param name="arg1">Size for division</param>
-        /// <param name="arg2">The Size to divide</param>
-        /// <returns>A Size containing the result of the division></returns>
+        /// <param name="arg1">Size for division.</param>
+        /// <param name="arg2">Size to divide.</param>
+        /// <returns>A size containing the result of the division.</returns>
         public static Size2D operator /(Size2D arg1, Size2D arg2)
         {
             return arg1.Divide(arg2);
         }
 
         /// <summary>
-        /// Division operator.
+        /// The division operator.
         /// </summary>
-        /// <param name="arg1">Size for division</param>
-        /// <param name="arg2">The int value to scale the Size by</param>
-        /// <returns>A Size containing the result of the scaling</returns>
+        /// <param name="arg1">Size for division.</param>
+        /// <param name="arg2">The integer value to scale the size by.</param>
+        /// <returns>A size containing the result of the scaling.</returns>
         public static Size2D operator /(Size2D arg1, int arg2)
         {
             return arg1.Divide(arg2);
         }
 
         /// <summary>
-        /// Array subscript operator.
+        /// The array subscript operator.
         /// </summary>
-        /// <param name="index">Subscript index</param>
-        /// <returns>The float at the given index</returns>
+        /// <param name="index">The subscript index.</param>
+        /// <returns>The float at the given index.</returns>
         public float this[uint index]
         {
             get
@@ -194,9 +194,9 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Get Size from pointer.
+        /// Gets the size from the pointer.
         /// </summary>
-        /// <param name="cPtr">Pointer of the Size</param>
+        /// <param name="cPtr">The pointer of the size.</param>
         /// <returns>Size</returns>
         internal static Size2D GetSize2DFromPtr(global::System.IntPtr cPtr)
         {
@@ -206,7 +206,7 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Constructor.
+        /// The constructor.
         /// </summary>
         public Size2D() : this(NDalicPINVOKE.new_Vector2__SWIG_0(), true)
         {
@@ -214,10 +214,10 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Constructor.
+        /// The constructor.
         /// </summary>
-        /// <param name="x">x (or width) component</param>
-        /// <param name="y">y (or height) component</param>
+        /// <param name="x">The x (or width) component.</param>
+        /// <param name="y">The y (or height) component.</param>
         public Size2D(int x, int y) : this(NDalicPINVOKE.new_Vector2__SWIG_1((float)x, (float)y), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
@@ -275,11 +275,11 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Check equality.<br>
+        /// Checks equality.<br>
         /// Utilizes appropriate machine epsilon values.<br>
         /// </summary>
-        /// <param name="rhs">The Size to test against</param>
-        /// <returns>True if the Sizes are equal</returns>
+        /// <param name="rhs">The size to test against.</param>
+        /// <returns>True if the sizes are equal.</returns>
         public bool EqualTo(Size2D rhs)
         {
             bool ret = NDalicPINVOKE.Vector2_EqualTo(swigCPtr, Size2D.getCPtr(rhs));
@@ -288,11 +288,11 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Check inequality.<br>
+        /// Checks inequality.<br>
         /// Utilizes appropriate machine epsilon values.<br>
         /// </summary>
-        /// <param name="rhs">The Size to test against</param>
-        /// <returns>True if the Sizes are not equal</returns>
+        /// <param name="rhs">The size to test against.</param>
+        /// <returns>True if the sizes are not equal.</returns>
         public bool NotEqualTo(Size2D rhs)
         {
             bool ret = NDalicPINVOKE.Vector2_NotEqualTo(swigCPtr, Size2D.getCPtr(rhs));
@@ -308,7 +308,7 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Property for width component of Size
+        /// The property for the width component of a size.
         /// </summary>
         public int Width
         {
@@ -326,7 +326,7 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Property for height component of Size
+        /// The property for the height component of a size.
         /// </summary>
         public int Height
         {
@@ -344,36 +344,36 @@ namespace Tizen.NUI
         }
 
         /// <summary>
-        /// Type cast operator, Size2D to Vector2.
+        /// The type cast operator, Size2D to Vector2.
         /// </summary>
-        /// <param name="size">Object of Size2D type</param>
+        /// <param name="size">An object of the Size2D type.</param>
         public static implicit operator Vector2(Size2D size)
         {
             return new Vector2((float)size.Width, (float)size.Height);
         }
 
         /// <summary>
-        /// Type cast operator, Vector2 to Size2D type.
+        /// The type cast operator, Vector2 to Size2D type.
         /// </summary>
-        /// <param name="vec">Object of Vector2 type</param>
+        /// <param name="vec">An object of the Vector2 type.</param>
         public static implicit operator Size2D(Vector2 vec)
         {
             return new Size2D((int)vec.X, (int)vec.Y);
         }
 
         /// <summary>
-        /// Type cast operator, Size2D to Uint16Pair.
+        /// The type cast operator, Size2D to Uint16Pair.
         /// </summary>
-        /// <param name="size2d">Object of Size2D type</param>
+        /// <param name="size2d">An object of the Size2D type.</param>
         public static implicit operator Uint16Pair(Size2D size2d)
         {
             return new Uint16Pair((uint)size2d.Width, (uint)size2d.Height);
         }
 
         /// <summary>
-        /// Type cast operator, Uint16Pair to Size2D type.
+        /// The type cast operator, Uint16Pair to Size2D type.
         /// </summary>
-        /// <param name="pair">Object of Vector2 type</param>
+        /// <param name="pair">An object of the Vector2 type.</param>
         public static implicit operator Size2D(Uint16Pair pair)
         {
             return new Size2D((int)pair.GetWidth(), (int)pair.GetWidth());