Add API comments

Change-Id: I8f0ae38d841fae59ef968d76011047cab2948baa

14 files changed, 504 insertions, 45 deletions

diff --git a/ElmSharp/ElmSharp/Background.cs b/ElmSharp/ElmSharp/Background.cs
index bb25d3b..0360458 100644..100755
--- a/ElmSharp/ElmSharp/Background.cs
+++ b/ElmSharp/ElmSharp/Background.cs
@@ -18,13 +18,24 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The Background is a widget that use for setting (solid) background decorations to a window (unless it has transparency enabled)
+    /// or to any container object.
+    /// </summary>
     public class Background : Layout
     {
+        /// <summary>
+        /// Creates and initializes a new instance of the Background class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new Background will be attached as a child.</param>
         public Background(EvasObject parent) : base(parent)
         {
             Style = "transparent";
         }
 
+        /// <summary>
+        /// Sets or gets color to Background.
+        /// </summary>
         public override Color Color
         {
             get
@@ -52,6 +63,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets image to Background.
+        /// </summary>
         public string File
         {
             get
@@ -64,6 +78,14 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the mode of display for a given background widget's image.
+        /// </summary>
+        /// <remarks>
+        /// This sets how the background widget will display its image.
+        /// This will only work if the File was previously set with an image file on obj.
+        /// The image can be display tiled, scaled, centered or stretched. scaled by default.
+        /// </remarks>
         public BackgroundOptions BackgroundOption
         {
             get
@@ -88,11 +110,27 @@ namespace ElmSharp
         }
     }
 
+    /// <summary>
+    /// Enumeration for the background type.
+    /// </summary>
     public enum BackgroundOptions
     {
+
+        /// <summary>
+        /// Centers the background image
+        /// </summary>
         Center,
+        /// <summary>
+        /// Scales the background image, retaining the aspect ratio
+        /// </summary>
         Scale,
+        /// <summary>
+        /// Stretches the background image to fill the UI component's area.
+        /// </summary>
         Stretch,
+        /// <summary>
+        /// Tiles the background image at its original size
+        /// </summary>
         Tile
     }
 }
diff --git a/ElmSharp/ElmSharp/Box.cs b/ElmSharp/ElmSharp/Box.cs
index c9c2142..721c04c 100644..100755
--- a/ElmSharp/ElmSharp/Box.cs
+++ b/ElmSharp/ElmSharp/Box.cs
@@ -18,14 +18,24 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The Box is a container used to arranges UI components in a linear order.
+    /// </summary>
     public class Box : Container
     {
         private Interop.Elementary.BoxLayoutCallback _layoutCallback;
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Box class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new Box will be attached as a child.</param>
         public Box(EvasObject parent) : base(parent)
         {
         }
 
+        /// <summary>
+        /// Sets or gets IsHorizontal value which describe pack direction, vertical is default.
+        /// </summary>
         public bool IsHorizontal
         {
             get
@@ -38,36 +48,78 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Adds an object at the end of the pack list.
+        /// </summary>
+        /// <remarks>
+        /// Packs "content" object into the Box, placing it last in the list of children objects.
+        /// The actual position the object will get on screen depends on the layout used.
+        /// If no custom layout is set, it will be at the bottom or right,
+        /// depending if the Box is vertical or horizontal, respectively.
+        /// </remarks>
+        /// <param name="content">The oject be packed</param>
         public void PackEnd(EvasObject content)
         {
             Interop.Elementary.elm_box_pack_end(RealHandle, content);
             AddChild(content);
         }
 
+        /// <summary>
+        /// Adds an "content" object to the beginning of the pack list.
+        /// </summary>
+        /// <remarks>
+        /// Pack "content" object into the Box obj, placing it first in the list of children objects.
+        /// The actual position the object will get on screen depends on the layout used.
+        /// If no custom layout is set, it will be at the top or left,
+        /// depending if the Box is vertical or horizontal, respectively.
+        /// </remarks>
+        /// <param name="content">The object to be packed.</param>
         public void PackStart(EvasObject content)
         {
             Interop.Elementary.elm_box_pack_start(RealHandle, content);
             AddChild(content);
         }
 
+        /// <summary>
+        /// Adds an "content "object to the Box after the "after" object.
+        /// </summary>
+        /// <remarks>
+        /// This will add the "content" to the Box indicated after the object indicated with "after".
+        /// If "after" is not already in the Box, results are undefined.
+        /// After means either to the right of the "after" object or below it depending on orientation.
+        /// </remarks>
+        /// <param name="content">The object will be added in Box</param>
+        /// <param name="after">The object has been added in Box</param>
         public void PackAfter(EvasObject content, EvasObject after)
         {
             Interop.Elementary.elm_box_pack_after(RealHandle, content, after);
             AddChild(content);
         }
 
+        /// <summary>
+        /// Remove the "content" oject from Box without deleting it.
+        /// </summary>
+        /// <param name="content">The object to unpack</param>
         public void UnPack(EvasObject content)
         {
             Interop.Elementary.elm_box_unpack(RealHandle, content);
             RemoveChild(content);
         }
 
+        /// <summary>
+        /// Removes all objects from Box container.
+        /// </summary>
         public void UnPackAll()
         {
             Interop.Elementary.elm_box_unpack_all(RealHandle);
             ClearChildren();
         }
 
+        /// <summary>
+        /// Whenever anything changes that requires the Box in obj to recalculate the size and position of its elements,
+        /// the function cb will be called to determine what the layout of the children will be.
+        /// </summary>
+        /// <param name="action">The callback function used for layout </param>
         public void SetLayoutCallback(Action action)
         {
             _layoutCallback = (obj, priv, data) =>
@@ -77,6 +129,11 @@ namespace ElmSharp
             Interop.Elementary.elm_box_layout_set(RealHandle, _layoutCallback, IntPtr.Zero, null);
         }
 
+        /// <summary>
+        /// Sets the color of color class to Box's layout parent.
+        /// </summary>
+        /// <param name="part">The name of color class. </param>
+        /// <param name="color">The color value.</param>
         public override void SetPartColor(string part, Color color)
         {
             Interop.Elementary.elm_object_color_class_color_set(Handle, part, color.R * color.A / 255,
@@ -85,6 +142,11 @@ namespace ElmSharp
                                                                               color.A);
         }
 
+        /// <summary>
+        /// Get the color of color class of Box's layout parent.
+        /// </summary>
+        /// <param name="part">The name of color class.</param>
+        /// <returns></returns>
         public override Color GetPartColor(string part)
         {
             int r, g, b, a;
diff --git a/ElmSharp/ElmSharp/Button.cs b/ElmSharp/ElmSharp/Button.cs
index 302bdf9..e369054 100644..100755
--- a/ElmSharp/ElmSharp/Button.cs
+++ b/ElmSharp/ElmSharp/Button.cs
@@ -18,6 +18,9 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The Button is a widget works as a clickable input element to trigger events.
+    /// </summary>
     public class Button : Layout
     {
         private SmartEvent _clicked;
@@ -25,6 +28,12 @@ namespace ElmSharp
         private SmartEvent _pressed;
         private SmartEvent _released;
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Button class.
+        /// </summary>
+        /// <param name="parent">
+        /// The EvasObject to which the new Button will be attached as a child.
+        /// </param>
         public Button(EvasObject parent) : base(parent)
         {
             _clicked = new SmartEvent(this, this.RealHandle, "clicked");
@@ -53,14 +62,36 @@ namespace ElmSharp
             };
         }
 
+        /// <summary>
+        /// Clicked will be triggered when Button is clicked.
+        /// </summary>
         public event EventHandler Clicked;
 
+        /// <summary>
+        /// Repeated will be triggered when Button is pressed without releasing it.
+        /// </summary>
         public event EventHandler Repeated;
 
+        /// <summary>
+        /// Pressed will be triggered when the Button is pressed.
+        /// </summary>
         public event EventHandler Pressed;
 
+        /// <summary>
+        /// Released will be triggered when the Button is released after being pressed.
+        /// </summary>
         public event EventHandler Released;
 
+        /// <summary>
+        /// Sets or gets the autorepeat feature of a given Button.
+        /// </summary>
+        /// <remarks>
+        /// Autorepeat feature means autorepeat event generated when the button is kept pressed.
+        /// When set AutoRepeat to false, no autorepeat is performed and buttons will trigger Clicked event when they are clicked.
+        /// When set to true, keeping a button pressed continuously trigger Repeated event until the button is released.
+        /// The time it takes until it starts triggering Repeated is given by AutoRepeatInitialTime,
+        /// and the time between each new emission is given by AutoRepeatGapTimeout.
+        /// </remarks>
         public bool AutoRepeat
         {
             get
@@ -73,6 +104,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the initial timeout before the Repeat event is generated.
+        /// </summary>
         public double AutoRepeatInitialTime
         {
             get
@@ -85,6 +119,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the interval between each generated Repeat event.
+        /// </summary>
         public double AutoRepeatGapTimeout
         {
             get
@@ -103,6 +140,9 @@ namespace ElmSharp
             Interop.Elementary.edje_object_color_class_del(Handle, part);
         }
 
+        /// <summary>
+        /// Sets or gets the BackgroundColor of a given Button in normal and pressed status.
+        /// </summary>
         public override Color BackgroundColor
         {
             set
diff --git a/ElmSharp/ElmSharp/Calendar.cs b/ElmSharp/ElmSharp/Calendar.cs
index 75cfef0..73ac989 100644..100755
--- a/ElmSharp/ElmSharp/Calendar.cs
+++ b/ElmSharp/ElmSharp/Calendar.cs
@@ -21,6 +21,9 @@ using System.Runtime.InteropServices;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The Calendar is a widget that helps applications to flexibly display a calender with day of the week, date, year and month.
+    /// </summary>
     public class Calendar : Layout
     {
         private SmartEvent _changed;
@@ -28,6 +31,12 @@ namespace ElmSharp
         private SmartEvent _displayedMonthChanged;
         private int _cacheDisplayedMonth;
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Calendar class.
+        /// </summary>
+        /// <param name="parent">
+        /// The EvasObject to which the new Calendar will be attached as a child.
+        /// </param>
         public Calendar(EvasObject parent) : base(parent)
         {
             _changed = new SmartEvent(this, this.RealHandle, "changed");
@@ -47,10 +56,19 @@ namespace ElmSharp
             };
         }
 
+        /// <summary>
+        /// DateChanged will be triggered when the date in the calendar is changed.
+        /// </summary>
         public event EventHandler<DateChangedEventArgs> DateChanged;
 
+        /// <summary>
+        /// DisplayedMonthChanged will be triggered when the current month displayed in the calendar is changed.
+        /// </summary>
         public event EventHandler<DisplayedMonthChangedEventArgs> DisplayedMonthChanged;
 
+        /// <summary>
+        /// Sets or gets the minimum for year.
+        /// </summary>
         public int MinimumYear
         {
             get
@@ -69,6 +87,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the maximum for the year.
+        /// </summary>
         public int MaximumYear
         {
             get
@@ -87,6 +108,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the first day of week, who are used on Calendar.
+        /// </summary>
         public DayOfWeek FirstDayOfWeek
         {
             get
@@ -99,6 +123,14 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the weekdays names to be displayed by the Calendar.
+        /// </summary>
+        /// <remarks>
+        /// The usage should be like this;
+        /// List<string> weekDayNames = new List<string>() { "S", "M", "T", "W", "T", "F", "S" };
+        /// Calendar.WeekDayNames = weekDayNames;
+        /// </remarks>
         public IReadOnlyList<string> WeekDayNames
         {
             get
@@ -117,6 +149,12 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the selected date.
+        /// </summary>
+        /// <remarks>
+        /// Selected date changes when the user goes to next/previous month or select a day pressing over it on calendar.
+        /// </remarks>
         public DateTime SelectedDate
         {
             get
@@ -133,6 +171,10 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the interval on time updates for an user mouse button
+        /// hold on calendar widgets' month/year selection.
+        /// </summary>
         public double Interval
         {
             get
diff --git a/ElmSharp/ElmSharp/Entry.cs b/ElmSharp/ElmSharp/Entry.cs
index 83a7e1b..3f310a7 100644..100755
--- a/ElmSharp/ElmSharp/Entry.cs
+++ b/ElmSharp/ElmSharp/Entry.cs
@@ -18,6 +18,9 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// A enum to describle InputPanel layout type.
+    /// </summary>
     public enum InputPanelLayout
     {
         /// <summary>
diff --git a/ElmSharp/ElmSharp/Panel.cs b/ElmSharp/ElmSharp/Panel.cs
index c6aac69..f644d27 100644..100755
--- a/ElmSharp/ElmSharp/Panel.cs
+++ b/ElmSharp/ElmSharp/Panel.cs
@@ -18,6 +18,9 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// Enumeration for paneldirection type.
+    /// </summary>
     public enum PanelDirection
     {
         /// <summary>
@@ -38,15 +41,26 @@ namespace ElmSharp
         Right,
     }
 
+    /// <summary>
+    /// The Panel is a container that can contain subobjects.
+    /// </summary>
     public class Panel : Layout
     {
         SmartEvent _toggled;
+
+        /// <summary>
+        /// Creates and initializes a new instance of Panel class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new Panel will be attached as a child.</param>
         public Panel(EvasObject parent) : base(parent)
         {
             _toggled = new SmartEvent(this, this.RealHandle, "toggled");
             _toggled.On += (s, e) => Toggled?.Invoke(this, EventArgs.Empty);
         }
 
+        /// <summary>
+        /// Sets or gets the hidden status of a given Panel widget.
+        /// </summary>
         public bool IsOpen
         {
             get
@@ -59,6 +73,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the direction of a given Panel widget.
+        /// </summary>
         public PanelDirection Direction
         {
             get
@@ -71,18 +88,36 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Toggled will be triggered when toggles Panel.
+        /// </summary>
         public event EventHandler Toggled;
 
+        /// <summary>
+        /// Enable or disable scrolling in the Panel.
+        /// </summary>
+        /// <param name="enable">
+        /// Bool value can be false or true.
+        /// </param>
         public void SetScrollable(bool enable)
         {
             Interop.Elementary.elm_panel_scrollable_set(RealHandle, enable);
         }
 
+        /// <summary>
+        /// Sets the scroll size of Panel.
+        /// </summary>
+        /// <param name="ratio">
+        /// The size of scroll area.
+        /// </param>
         public void SetScrollableArea(double ratio)
         {
             Interop.Elementary.elm_panel_scrollable_content_size_set(RealHandle, ratio);
         }
 
+        /// <summary>
+        /// Toggles the hidden state of the Panel.
+        /// </summary>
         public void Toggle()
         {
             Interop.Elementary.elm_panel_toggle(RealHandle);
diff --git a/ElmSharp/ElmSharp/Panes.cs b/ElmSharp/ElmSharp/Panes.cs
index 3a223ae..1523c09 100644..100755
--- a/ElmSharp/ElmSharp/Panes.cs
+++ b/ElmSharp/ElmSharp/Panes.cs
@@ -18,10 +18,19 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The Panes is a widget that adds a draggable bar between two contents.
+    /// When dragged this bar resizes contents' size.
+    /// </summary>
     public class Panes : Layout
     {
         SmartEvent _press;
         SmartEvent _unpressed;
+
+        /// <summary>
+        /// Creates and initializes a new instance of the Panes class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new Panes will be attached as a child.</param>
         public Panes(EvasObject parent) : base(parent)
         {
             _press = new SmartEvent(this, this.RealHandle, "press");
@@ -31,8 +40,20 @@ namespace ElmSharp
             _unpressed.On += (s, e) => Unpressed?.Invoke(this, e);
         }
 
+        /// <summary>
+        /// Pressed will be triggered when panes have been pressed (button isn't released yet).
+        /// </summary>
         public event EventHandler Pressed;
+
+        /// <summary>
+        /// Unpressed will be triggered when panes are released after being pressed.
+        /// </summary>
         public event EventHandler Unpressed;
+
+        /// <summary>
+        /// Sets or gets resize mode of a given Panes widget.
+        /// True means the left and right panes resize homogeneously.
+        /// </summary>
         public bool IsFixed
         {
             get
@@ -45,6 +66,18 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or Gets the size proportion of the Panes widget's left side.
+        /// </summary>
+        /// <remarks>
+        /// By default it's homogeneous, i.e., both sides have the same size.If something different is required,
+        /// it can be set with this function. For example, if the left content should be displayed over 75% of the panes size,
+        /// size should be passed as 0.75. This way, the right content is resized to 25% of the panes size.
+        /// If displayed vertically, left content is displayed at the top, and right content at the bottom.
+        /// This proportion changes when the user drags the panes bar.
+        ///
+        /// The value is float type and between 0.0 and 1.0 representing the size proportion of the left side.
+        /// </remarks>
         public double Proportion
         {
             get
@@ -57,6 +90,13 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the orientation of a given Panes widget.
+        /// </summary>
+        /// <remarks>
+        /// Uses this function to change how your panes are to be disposed: vertically or horizontally.
+        /// By default it's displayed horizontally.
+        /// </remarks>
         public bool IsHorizontal
         {
             get
diff --git a/ElmSharp/ElmSharp/Point.cs b/ElmSharp/ElmSharp/Point.cs
index 300600a..3fe04cd 100644..100755
--- a/ElmSharp/ElmSharp/Point.cs
+++ b/ElmSharp/ElmSharp/Point.cs
@@ -19,7 +19,7 @@ using System;
 namespace ElmSharp
 {
     /// <summary>
-    /// Struct defining a 2-D point as a pair of generic type.
+    /// The Point is a struct that defines a 2-D point as a pair of generic type.
     /// </summary>
     public struct Point : IEquatable<Point>
     {
@@ -33,19 +33,11 @@ namespace ElmSharp
         /// </summary>
         public int Y;
 
-        /// <summary>
-        /// A human-readable representation of the <see cref="T:Tizen.UI.Point" />.
-        /// </summary>
-        /// <returns>The string is formatted as "{{X={0} Y={1}}}".</returns>
         public override string ToString()
         {
             return string.Format("{{X={0} Y={1}}}", X, Y);
         }
 
-        /// <summary>
-        /// Returns a hash value for the <see cref="T:Tizen.UI.Point" />.
-        /// </summary>
-        /// <returns>A value intended for efficient insertion and lookup in hashtable-based data structures.</returns>
         public override int GetHashCode()
         {
             unchecked
@@ -54,11 +46,6 @@ namespace ElmSharp
             }
         }
 
-        /// <summary>
-        /// Returns true if the X and Y values of this are exactly equal to those in the argument.
-        /// </summary>
-        /// <param name="obj">Another <see cref="T:Tizen.UI.Point" />.</param>
-        /// <returns>True if the X and Y values are equal to those in <paramref name="obj" />. Returns false if <paramref name="obj" /> is not a <see cref="T:Tizen.UI.Point" />.</returns>
         public override bool Equals(object obj)
         {
             if (!(obj is Point))
@@ -67,11 +54,6 @@ namespace ElmSharp
             return Equals((Point)obj);
         }
 
-        /// <summary>
-        /// Returns true if the X and Y values of this are exactly equal to those in the argument.
-        /// </summary>
-        /// <param name="other">Another <see cref="T:Tizen.UI.Point" />.</param>
-        /// <returns>True if the X and Y values are equal to those in <paramref name="other" />.</returns>
         public bool Equals(Point other)
         {
             return X.Equals(other.X) && Y.Equals(other.Y);
diff --git a/ElmSharp/ElmSharp/Point3D.cs b/ElmSharp/ElmSharp/Point3D.cs
index 1ac96af..577c816 100644..100755
--- a/ElmSharp/ElmSharp/Point3D.cs
+++ b/ElmSharp/ElmSharp/Point3D.cs
@@ -38,19 +38,11 @@ namespace ElmSharp
         /// </summary>
         public int Z;
 
-        /// <summary>
-        /// A human-readable representation of the <see cref="T:Tizen.UI.Point3D" />.
-        /// </summary>
-        /// <returns>The string is formatted as "{{X={0} Y={1} Z={2}}}".</returns>
         public override string ToString()
         {
             return string.Format("{{X={0} Y={1} Z={2}}}", X, Y, Z);
         }
 
-        /// <summary>
-        /// Returns a hash value for the <see cref="T:Tizen.UI.Point3D" />.
-        /// </summary>
-        /// <returns>A value intended for efficient insertion and lookup in hashtable-based data structures.</returns>
         public override int GetHashCode()
         {
             unchecked
@@ -62,11 +54,6 @@ namespace ElmSharp
             }
         }
 
-        /// <summary>
-        /// Returns true if the X, Y and Z values of this are exactly equal to those in the argument.
-        /// </summary>
-        /// <param name="obj">Another <see cref="T:Tizen.UI.Point3D" />.</param>
-        /// <returns>True if the X, Y and Z values are equal to those in <paramref name="obj" />. Returns false if <paramref name="obj" /> is not a <see cref="T:Tizen.UI.Point" />.</returns>
         public override bool Equals(object obj)
         {
             if (!(obj is Point3D))
@@ -75,11 +62,6 @@ namespace ElmSharp
             return Equals((Point3D)obj);
         }
 
-        /// <summary>
-        /// Returns true if the X, Y and Z values of this are exactly equal to those in the argument.
-        /// </summary>
-        /// <param name="other">Another <see cref="T:Tizen.UI.Point3D" />.</param>
-        /// <returns>True if the X, Y and Z values are equal to those in <paramref name="other" />.</returns>
         public bool Equals(Point3D other)
         {
             return X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z);
diff --git a/ElmSharp/ElmSharp/Polygon.cs b/ElmSharp/ElmSharp/Polygon.cs
index e669a70..5db398d 100644..100755
--- a/ElmSharp/ElmSharp/Polygon.cs
+++ b/ElmSharp/ElmSharp/Polygon.cs
@@ -19,20 +19,20 @@ using System;
 namespace ElmSharp
 {
     /// <summary>
-    /// A view used to draw a polygon (filled).
+    /// The Polygon is a widget that used to draw a polygon (filled).
     /// </summary>
     public class Polygon : EvasObject
     {
         /// <summary>
-        /// Create a new Polygon widget.
-        /// <param name="p">The EvasObject to which the new Polygon will be attached as a child.</param>
+        /// Creates and initializes a new instance of the Polygon class.
+        /// <param name="parent">The EvasObject to which the new Polygon will be attached as a child.</param>
         /// </summary>
         public Polygon(EvasObject parent) : base(parent)
         {
         }
 
         /// <summary>
-        /// Adds a new vertex to the polygon.
+        /// Adds a new vertex to the Polygon.
         /// <param name="x">The X coordinate of the new vertex.</param>
         /// <param name="y">The Y coordinate of the new vertex.</param>
         /// </summary>
@@ -42,7 +42,7 @@ namespace ElmSharp
         }
 
         /// <summary>
-        /// Adds a new vertex to the polygon.
+        /// Adds a new vertex to the Polygon.
         /// <param name="p">The coordinates of the new vertex.</param>
         /// </summary>
         public void AddPoint(Point p)
@@ -51,7 +51,7 @@ namespace ElmSharp
         }
 
         /// <summary>
-        /// Removes all the vertices of the polygon, making it empty.
+        /// Removes all the vertices of the Polygon, making it empty.
         /// </summary>
         public void ClearPoints()
         {
diff --git a/ElmSharp/ElmSharp/Popup.cs b/ElmSharp/ElmSharp/Popup.cs
index bb17baa..503a0db 100644..100755
--- a/ElmSharp/ElmSharp/Popup.cs
+++ b/ElmSharp/ElmSharp/Popup.cs
@@ -19,19 +19,53 @@ using System.Collections.Generic;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// Enumeration for the popup orientation type.
+    /// </summary>
     public enum PopupOrientation
     {
+        /// <summary>
+        /// Appears in the top of parent, default.
+        /// </summary>
         Top,
+        /// <summary>
+        /// Appears in the center of parent.
+        /// </summary>
         Center,
+        /// <summary>
+        /// Appears in the bottom of parent.
+        /// </summary>
         Bottom,
+        /// <summary>
+        /// Appears in the left of parent.
+        /// </summary>
         Left,
+        /// <summary>
+        /// Appears in the right of parent.
+        /// </summary>
         Right,
+        /// <summary>
+        /// Appears in the top left of parent.
+        /// </summary>
         TopLeft,
+        /// <summary>
+        /// Appears in the top right of parent.
+        /// </summary>
         TopRight,
+        /// <summary>
+        /// Appears in the bottom left of parent.
+        /// </summary>
         BottomLeft,
+        /// <summary>
+        /// Appears in the bottom right of parent.
+        /// </summary>
         BottomRight
     }
 
+    /// <summary>
+    /// This Popup is a widget that is an enhancement of Notify.
+    /// In addition to content area, there are two optional sections, namely title area and action area.
+    /// </summary>
     public class Popup : Layout
     {
         HashSet<PopupItem> _children = new HashSet<PopupItem>();
@@ -40,6 +74,10 @@ namespace ElmSharp
         SmartEvent _timeout;
         SmartEvent _showFinished;
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Popup class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new Popup will be attached as a child.</param>
         public Popup(EvasObject parent) : base(parent)
         {
             _dismissed = new SmartEvent(this, "dismissed");
@@ -67,14 +105,29 @@ namespace ElmSharp
             };
         }
 
+        /// <summary>
+        /// Dismissed will be triggered when Popup have been dismissed.
+        /// </summary>
         public event EventHandler Dismissed;
 
+        /// <summary>
+        /// OutsideClicked will be triggered when users taps on the outside of Popup.
+        /// </summary>
         public event EventHandler OutsideClicked;
 
+        /// <summary>
+        /// OutsideClicked will be triggered when Popup is closed as a result of timeout.
+        /// </summary>
         public event EventHandler TimedOut;
 
+        /// <summary>
+        /// OutsideClicked will be triggered when the Popup transition is finished in showing.
+        /// </summary>
         public event EventHandler ShowAnimationFinished;
 
+        /// <summary>
+        /// Sets or gets the position in which Popup will appear in its parent.
+        /// </summary>
         public PopupOrientation Orientation
         {
             get
@@ -87,6 +140,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the wrapping type of content text packed in content area of Popup widget.
+        /// </summary>
         public WrapType ContentTextWrapType
         {
             get
@@ -99,6 +155,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the timeout value set to the Popup(in seconds).
+        /// </summary>
         public double Timeout
         {
             get
@@ -111,6 +170,12 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets whether events should be passed to event blocked area by a click outside.
+        /// </summary>
+        /// <remarks>
+        /// The visible region of popup is surrounded by a translucent region called Blocked Event area.
+        /// </remarks>
         public bool AllowEvents
         {
             get
@@ -123,6 +188,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the AlignmentX in which the popup will appear in its parent.
+        /// </summary>
         public override double AlignmentX
         {
             get
@@ -135,6 +203,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the AlignmentY in which the popup will appear in its parent.
+        /// </summary>
         public override double AlignmentY
         {
             get
@@ -147,6 +218,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Gets the Opacity value set to the Popup(in seconds).
+        /// </summary>
         public override int Opacity
         {
             get
@@ -160,11 +234,22 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Adds label to a Popup widget.
+        /// </summary>
+        /// <param name="label"></param>
+        /// <returns>The new PopupItem which contains label .</returns>
         public PopupItem Append(string label)
         {
             return Append(label, null);
         }
 
+        /// <summary>
+        /// Adds Label and icon to a Popup widget.
+        /// </summary>
+        /// <param name="label">The Label which will be added into a new PopupItem. </param>
+        /// <param name="icon">The icon which will be added into a new PopupItem. </param>
+        /// <returns>The new PopupItem which contains label and icon.</returns>
         public PopupItem Append(string label, EvasObject icon)
         {
             PopupItem item = new PopupItem(label, icon);
@@ -173,6 +258,10 @@ namespace ElmSharp
             return item;
         }
 
+        /// <summary>
+        /// Uses this function to dismiss the popup in hide effect.
+        /// when the Popup is dismissed, the "dismissed" signal will be emitted.
+        /// </summary>
         public void Dismiss()
         {
             Interop.Elementary.elm_popup_dismiss(Handle);
@@ -182,13 +271,11 @@ namespace ElmSharp
         {
             return Interop.Elementary.elm_popup_add(parent.Handle);
         }
-
         void AddInternal(PopupItem item)
         {
             _children.Add(item);
             item.Deleted += Item_Deleted;
         }
-
         void Item_Deleted(object sender, EventArgs e)
         {
             _children.Remove((PopupItem)sender);
diff --git a/ElmSharp/ElmSharp/ProgressBar.cs b/ElmSharp/ElmSharp/ProgressBar.cs
index 1e65072..b32e353 100644..100755
--- a/ElmSharp/ElmSharp/ProgressBar.cs
+++ b/ElmSharp/ElmSharp/ProgressBar.cs
@@ -18,10 +18,17 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The ProgressBar is a widget for visually representing the progress status of a given job/task.
+    /// </summary>
     public class ProgressBar : Layout
     {
         SmartEvent _changed;
 
+        /// <summary>
+        /// Creates and initializes a new instance of the ProgressBar class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new ProgressBar will be attached as a child.</param>
         public ProgressBar(EvasObject parent) : base(parent)
         {
             _changed = new SmartEvent(this, this.RealHandle, "changed");
@@ -31,8 +38,22 @@ namespace ElmSharp
             };
         }
 
+        /// <summary>
+        /// ValueChanged will be triggered when value of ProgressBar change.
+        /// </summary>
         public event EventHandler ValueChanged;
 
+        /// <summary>
+        /// Sets or gets the value wheather a given ProgressBar widget is at the "pulsing mode".
+        /// </summary>
+        /// <remarks>
+        /// By default, progress bars display values from low to high value boundaries.
+        /// There are, though, contexts in which the progress of a given task is unknown.
+        /// For such cases, one can set a progress bar widget to a "pulsing state",
+        /// to give the user an idea that some computation is being held,
+        /// but without exact progress values. In the default theme,
+        /// it animates its bar with the contents filling in constantly and back to non-filled, in a loop.
+        /// </remarks>
         public bool IsPulseMode
         {
             get
@@ -45,6 +66,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the value of ProgressBar.
+        /// </summary>
         public double Value
         {
             get
@@ -57,6 +81,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the span value of ProgressBar.
+        /// </summary>
         public int SpanSize
         {
             get
@@ -69,6 +96,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the value wheather a given ProgressBar widget is horizontal.
+        /// </summary>
         public bool IsHorizontal
         {
             get
@@ -81,6 +111,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the value whether a given progress bar widget's displaying values are inverted.
+        /// </summary>
         public bool IsInverted
         {
             get
@@ -93,6 +126,16 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets format string for a given progress bar widget's units label.
+        /// </summary>
+        /// <remarks>
+        /// If NULL is passed on format, it makes obj units area to be hidden completely.
+        /// If not, it sets the format string for the units label's text.
+        /// The units label is provided with a floating point value, so the units text displays at most one floating point value.
+        /// Note that the units label is optional. Use a format string such as "%1.2f meters" for example.
+        /// The default format string for a progress bar is an integer percentage, as in "%.0f %%".
+        /// </remarks>
         public string UnitFormat
         {
             get
@@ -105,6 +148,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Starts a given progress bar "pulsing" animation, if its under that mode.
+        /// </summary>
         public void PlayPulse()
         {
             Interop.Elementary.elm_progressbar_pulse(RealHandle, true);
@@ -116,6 +162,9 @@ namespace ElmSharp
             Interop.Elementary.elm_progressbar_pulse(RealHandle, false);
         }
 
+        /// <summary>
+        /// Stops a given progress bar "pulsing" animation, if its under that mode.
+        /// </summary>
         public void StopPulse()
         {
             Interop.Elementary.elm_progressbar_pulse(RealHandle, false);
diff --git a/ElmSharp/ElmSharp/Radio.cs b/ElmSharp/ElmSharp/Radio.cs
index dec0c58..9a5f2d5 100644..100755
--- a/ElmSharp/ElmSharp/Radio.cs
+++ b/ElmSharp/ElmSharp/Radio.cs
@@ -18,18 +18,31 @@ using System;
 
 namespace ElmSharp
 {
+    /// <summary>
+    /// The Radio is a widget that allows for 1 or more options to be displayed and have the user choose only 1 of them.
+    /// </summary>
     public class Radio : Layout
     {
         SmartEvent _changed;
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Radio class.
+        /// </summary>
+        /// <param name="parent">The EvasObject to which the new Radio will be attached as a child.</param>
         public Radio(EvasObject parent) : base(parent)
         {
             _changed = new SmartEvent(this, this.RealHandle, "changed");
             _changed.On += (s, e) => ValueChanged?.Invoke(this, EventArgs.Empty);
         }
 
+        /// <summary>
+        /// ValueChanged will be triggered when value of Radio change.
+        /// </summary>
         public event EventHandler ValueChanged;
 
+        /// <summary>
+        /// Sets or gets a unique value to each Radio button.
+        /// </summary>
         public int StateValue
         {
             get
@@ -42,6 +55,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets the value of the radio group.
+        /// </summary>
         public int GroupValue
         {
             get
@@ -54,6 +70,10 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Adds this radio to a group of other radio objects.
+        /// </summary>
+        /// <param name="group">Group which add radio in.</param>
         public void SetGroup(Radio group)
         {
             if (group == null)
diff --git a/ElmSharp/ElmSharp/Window.cs b/ElmSharp/ElmSharp/Window.cs
index be5a376..74e331e 100644..100755
--- a/ElmSharp/ElmSharp/Window.cs
+++ b/ElmSharp/ElmSharp/Window.cs
@@ -28,6 +28,9 @@ namespace ElmSharp
         Degree_270 = 8
     };
 
+    /// <summary>
+    /// Enum indicator opacity
+    /// </summary>
     public enum StatusBarMode
     {
         /// <summary>
@@ -49,16 +52,37 @@ namespace ElmSharp
         Transparent = 3,
     }
 
+    /// <summary>
+    /// The Window is container that contain the graphical user interface of a program.
+    /// </summary>
     public class Window : Widget
     {
         SmartEvent _deleteRequest;
         SmartEvent _rotationChanged;
         HashSet<EvasObject> _referenceHolder = new HashSet<EvasObject>();
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Window class.
+        /// </summary>
+        /// <param name="name">Window name.</param>
         public Window(string name) : this(null, name)
         {
         }
 
+        /// <summary>
+        /// Creates and initializes a new instance of the Window class.
+        /// </summary>
+        /// <param name="parent">
+        /// Parent widget which this widow created on.
+        /// </param>
+        /// <param name="name">
+        /// Window name.
+        /// </param>
+        /// <remarks>
+        /// Window constructor.show window indicator,set callback
+        /// When closing the window in any way outside the program control,
+        /// and set callback when window rotation changed.
+        /// </remarks>
         public Window(Window parent, string name)
         {
             Name = name;
@@ -75,11 +99,24 @@ namespace ElmSharp
         {
         }
 
+        /// <summary>
+        /// CloseRequested will be triggered when Window close.
+        /// </summary>
         public event EventHandler CloseRequested;
+
+        /// <summary>
+        /// RotationChanged will be triggered when Window do rotation.
+        /// </summary>
         public event EventHandler RotationChanged;
 
+        /// <summary>
+        /// Sets or gets Window name.
+        /// </summary>
         public string Name { get; set; }
 
+        /// <summary>
+        /// Gets Window size with Size value(w,h)
+        /// </summary>
         public Size ScreenSize
         {
             get
@@ -90,6 +127,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Gets the screen dpi for the screen that a Window is on.
+        /// </summary>
         public Point ScreenDpi
         {
             get
@@ -100,6 +140,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Gets the rotation of the Window.The rotation of the window in degrees (0-360).
+        /// </summary>
         public int Rotation
         {
             get
@@ -108,6 +151,9 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets value whether rotation is supported.
+        /// </summary>
         public bool IsRotationSupported
         {
             get
@@ -119,6 +165,10 @@ namespace ElmSharp
         [Obsolete("Sorry, it's error typo of AvailableRotations, please use AvailableRotations")]
         public DisplayRotation AavailableRotations { get; set; }
 
+
+        /// <summary>
+        /// Sets or gets available rotation degree.
+        /// </summary>
         public DisplayRotation AvailableRotations
         {
             get
@@ -137,6 +187,13 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// Sets or gets whether auto deletion function is enable.
+        /// </summary>
+        /// <remarks>
+        /// If you enable auto deletion, the window is automatically destroyed after the signal is emitted.
+        /// If auto deletion is disabled, the window is not destroyed and the program has to handle it.
+        /// </remarks>
         public bool AutoDeletion
         {
             get
@@ -185,16 +242,37 @@ namespace ElmSharp
             }
         }
 
+        /// <summary>
+        /// This function sends a request to the Windows Manager to activate the Window.
+        /// If honored by the WM, the window receives the keyboard focus.
+        /// </summary>
+        /// <remarks>
+        /// This is just a request that a Window Manager may ignore, so calling this function does not ensure
+        /// in any way that the window is going to be the active one after it.
+        /// </remarks>
         public void Active()
         {
             Interop.Elementary.elm_win_activate(Handle);
         }
 
+        /// <summary>
+        /// Adds obj as a resize object of the Window.
+        /// </summary>
+        /// <remarks>
+        /// Setting an object as a resize object of the window means that the obj child's size and
+        /// position is controlled by the window directly. That is, the obj is resized to match the window size
+        /// and should never be moved or resized manually by the developer.In addition,
+        /// resize objects of the window control the minimum size of it as well as whether it can or cannot be resized by the user.
+        /// </remarks>
+        /// <param name="obj">
+        /// Resize object.
+        /// </param>
         public void AddResizeObject(EvasObject obj)
         {
             Interop.Elementary.elm_win_resize_object_add(Handle, obj);
         }
 
+
         protected override IntPtr CreateHandle(EvasObject parent)
         {
             Interop.Elementary.elm_config_accel_preference_set("3d");
@@ -211,6 +289,7 @@ namespace ElmSharp
             _referenceHolder.Remove(obj);
         }
 
+        /// </return>
         static int[] ConvertDegreeArray(DisplayRotation value)
         {
             List<int> rotations = new List<int>();