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
}
}
+ /// <summary>
+ /// Sets or gets image to Background.
+ /// </summary>
public string File
{
get
}
}
+ /// <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
}
}
+ /// <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
}
}
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
}
}
+ /// <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) =>
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,
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;
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;
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");
};
}
+ /// <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
}
}
+ /// <summary>
+ /// Sets or gets the initial timeout before the Repeat event is generated.
+ /// </summary>
public double AutoRepeatInitialTime
{
get
}
}
+ /// <summary>
+ /// Sets or gets the interval between each generated Repeat event.
+ /// </summary>
public double AutoRepeatGapTimeout
{
get
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
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;
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");
};
}
+ /// <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
}
}
+ /// <summary>
+ /// Sets or gets the maximum for the year.
+ /// </summary>
public int MaximumYear
{
get
}
}
+ /// <summary>
+ /// Sets or gets the first day of week, who are used on Calendar.
+ /// </summary>
public DayOfWeek FirstDayOfWeek
{
get
}
}
+ /// <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
}
}
+ /// <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
}
}
+ /// <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
namespace ElmSharp
{
+ /// <summary>
+ /// A enum to describle InputPanel layout type.
+ /// </summary>
public enum InputPanelLayout
{
/// <summary>
namespace ElmSharp
{
+ /// <summary>
+ /// Enumeration for paneldirection type.
+ /// </summary>
public enum PanelDirection
{
/// <summary>
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
}
}
+ /// <summary>
+ /// Sets or gets the direction of a given Panel widget.
+ /// </summary>
public PanelDirection Direction
{
get
}
}
+ /// <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);
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");
_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
}
}
+ /// <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
}
}
+ /// <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
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>
{
/// </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
}
}
- /// <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))
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);
/// </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
}
}
- /// <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))
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);
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>
}
/// <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)
}
/// <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()
{
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>();
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");
};
}
+ /// <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
}
}
+ /// <summary>
+ /// Sets or gets the wrapping type of content text packed in content area of Popup widget.
+ /// </summary>
public WrapType ContentTextWrapType
{
get
}
}
+ /// <summary>
+ /// Sets or gets the timeout value set to the Popup(in seconds).
+ /// </summary>
public double Timeout
{
get
}
}
+ /// <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
}
}
+ /// <summary>
+ /// Sets or gets the AlignmentX in which the popup will appear in its parent.
+ /// </summary>
public override double AlignmentX
{
get
}
}
+ /// <summary>
+ /// Sets or gets the AlignmentY in which the popup will appear in its parent.
+ /// </summary>
public override double AlignmentY
{
get
}
}
+ /// <summary>
+ /// Gets the Opacity value set to the Popup(in seconds).
+ /// </summary>
public override int Opacity
{
get
}
}
+ /// <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);
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);
{
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);
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");
};
}
+ /// <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
}
}
+ /// <summary>
+ /// Sets or gets the value of ProgressBar.
+ /// </summary>
public double Value
{
get
}
}
+ /// <summary>
+ /// Sets or gets the span value of ProgressBar.
+ /// </summary>
public int SpanSize
{
get
}
}
+ /// <summary>
+ /// Sets or gets the value wheather a given ProgressBar widget is horizontal.
+ /// </summary>
public bool IsHorizontal
{
get
}
}
+ /// <summary>
+ /// Sets or gets the value whether a given progress bar widget's displaying values are inverted.
+ /// </summary>
public bool IsInverted
{
get
}
}
+ /// <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
}
}
+ /// <summary>
+ /// Starts a given progress bar "pulsing" animation, if its under that mode.
+ /// </summary>
public void PlayPulse()
{
Interop.Elementary.elm_progressbar_pulse(RealHandle, true);
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);
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
}
}
+ /// <summary>
+ /// Sets or gets the value of the radio group.
+ /// </summary>
public int GroupValue
{
get
}
}
+ /// <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)
Degree_270 = 8
};
+ /// <summary>
+ /// Enum indicator opacity
+ /// </summary>
public enum StatusBarMode
{
/// <summary>
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;
{
}
+ /// <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
}
}
+ /// <summary>
+ /// Gets the screen dpi for the screen that a Window is on.
+ /// </summary>
public Point ScreenDpi
{
get
}
}
+ /// <summary>
+ /// Gets the rotation of the Window.The rotation of the window in degrees (0-360).
+ /// </summary>
public int Rotation
{
get
}
}
+ /// <summary>
+ /// Sets or gets value whether rotation is supported.
+ /// </summary>
public bool IsRotationSupported
{
get
[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
}
}
+ /// <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
}
}
+ /// <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");
_referenceHolder.Remove(obj);
}
+ /// </return>
static int[] ConvertDegreeArray(DisplayRotation value)
{
List<int> rotations = new List<int>();
projects / platform / core / csapi / elm-sharp.git / commitdiff