}
/// <summary>
+ /// Dispose
/// </summary>
public virtual void Dispose()
{
}
}
-
/// <summary>
- /// Addition operator.
+ /// 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>
public static Size operator +(Size arg1, Size arg2)
{
return arg1.Add(arg2);
}
/// <summary>
- /// Subtraction operator.
+ /// 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>
public static Size operator -(Size arg1, Size arg2)
{
return arg1.Subtract(arg2);
}
/// <summary>
- ///
+ /// Unary negation operator.
/// </summary>
+ /// <param name="arg1">Size for unary negation</param>
+ /// <returns>A Size containg the negation</returns>
public static Size operator -(Size arg1)
{
return arg1.Subtract();
/// <summary>
/// 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>
public static Size operator *(Size arg1, Size arg2)
{
return arg1.Multiply(arg2);
/// <summary>
/// Multiplication operator.
/// </summary>
+ /// <param name="arg1">Size for multiplication</param>
+ /// <param name="arg2">The float value to scale the Size</param>
+ /// <returns>A Size containing the result of the scaling</returns>
public static Size operator *(Size arg1, float arg2)
{
return arg1.Multiply(arg2);
/// <summary>
/// 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>
public static Size operator /(Size arg1, Size arg2)
{
return arg1.Divide(arg2);
/// <summary>
/// Division operator.
/// </summary>
+ /// <param name="arg1">Size for division</param>
+ /// <param name="arg2">The float value to scale the Size by</param>
+ /// <returns>A Size containing the result of the scaling</returns>
public static Size operator /(Size arg1, float arg2)
{
return arg1.Divide(arg2);
/// <summary>
/// Array subscript operator.
/// </summary>
+ /// <param name="index">Subscript index</param>
+ /// <returns>The float at the given index</returns>
public float this[uint index]
{
get
}
/// <summary>
+ /// Get Size from pointer.
/// </summary>
+ /// <param name="cPtr">Pointer of the Size</param>
+ /// <returns>Size</returns>
public static Size GetSizeFromPtr(global::System.IntPtr cPtr)
{
Size ret = new Size(cPtr, false);
/// <summary>
/// Constructor.
/// </summary>
+ /// <param name="x">x (or width) component</param>
+ /// <param name="y">y (or height) component</param>
+ /// <param name="z">z (or depth) component</param>
public Size(float x, float y, float z) : this(NDalicPINVOKE.new_Vector3__SWIG_1(x, y, z), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
/// <summary>
/// Constructor.
/// </summary>
+ /// <param name="size2d">Size2D with x (width) and y (height)</param>
public Size(Size2D size2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Size2D.getCPtr(size2d)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
+ /// Zero constant, (0.0f, 0.0f, 0.0f).
/// </summary>
public static Size Zero
{
/// Check equality.
/// Utilizes appropriate machine epsilon values.
/// </summary>
+ /// <param name="rhs">The Size to test against</param>
+ /// <returns>True if the Sizes are equal</returns>
public bool EqualTo(Size rhs)
{
bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Size.getCPtr(rhs));
/// Check inequality.
/// Utilizes appropriate machine epsilon values.
/// </summary>
+ /// <param name="rhs">The Size to test against</param>
+ /// <returns>True if the Sizes are not equal</returns>
public bool NotEqualTo(Size rhs)
{
bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Size.getCPtr(rhs));
}
/// <summary>
+ /// Width property for width component of Siz
/// </summary>
public float Width
{
}
/// <summary>
+ /// Height property for height component of Size
/// </summary>
public float Height
{
}
/// <summary>
+ /// Depth property for depth component of Size
/// </summary>
public float Depth
{
}
/// <summary>
+ /// Type cast operator, Size to Vector3.
/// </summary>
+ /// <param name="size">Object of Size type</param>
public static implicit operator Vector3(Size size)
{
return new Vector3(size.Width, size.Height, size.Depth);
}
/// <summary>
+ /// Type cast operator, Vector3 to Size type.
/// </summary>
+ /// <param name="vec">Object of Vector3 type</param>
public static implicit operator Size(Vector3 vec)
{
return new Size(vec.Width, vec.Height, vec.Depth);
}
/// <summary>
+ /// Dispose
/// </summary>
public virtual void Dispose()
{
}
/// <summary>
- /// Addition operator.
+ /// 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>
public static Size2D operator +(Size2D arg1, Size2D arg2)
{
return arg1.Add(arg2);
}
/// <summary>
- /// Subtraction operator.
+ /// 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>
public static Size2D operator -(Size2D arg1, Size2D arg2)
{
return arg1.Subtract(arg2);
}
/// <summary>
+ /// Unary negation operator.
/// </summary>
+ /// <param name="arg1">Size for unary negation</param>
+ /// <returns>A Size containg the negation</returns>
public static Size2D operator -(Size2D arg1)
{
return arg1.Subtract();
/// <summary>
/// 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>
public static Size2D operator *(Size2D arg1, Size2D arg2)
{
return arg1.Multiply(arg2);
/// <summary>
/// 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>
+
public static Size2D operator *(Size2D arg1, int arg2)
{
return arg1.Multiply(arg2);
/// <summary>
/// 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>
public static Size2D operator /(Size2D arg1, Size2D arg2)
{
return arg1.Divide(arg2);
/// <summary>
/// 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>
public static Size2D operator /(Size2D arg1, int arg2)
{
return arg1.Divide(arg2);
/// <summary>
/// Array subscript operator.
/// </summary>
+ /// <param name="index">Subscript index</param>
+ /// <returns>The float at the given index</returns>
public float this[uint index]
{
get
}
/// <summary>
+ /// Get Size from pointer.
+ /// </summary>
+ /// <param name="cPtr">Pointer of the Size</param>
+ /// <returns>Size</returns>
public static Size2D GetSize2DFromPtr(global::System.IntPtr cPtr)
{
Size2D ret = new Size2D(cPtr, false);
/// <summary>
/// Constructor.
/// </summary>
+ /// <param name="x">x (or width) component</param>
+ /// <param name="y">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();
/// <summary>
/// Constructor.
/// </summary>
+ /// <param name="size">Size with x (width), y (height), and z (depth)</param>
public Size2D(Size size) : this(NDalicPINVOKE.new_Vector2__SWIG_3(Size.getCPtr(size)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
/// Check equality.
/// Utilizes appropriate machine epsilon values.
/// </summary>
+ /// <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));
/// Check inequality.
/// Utilizes appropriate machine epsilon values.
/// </summary>
+ /// <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));
}
/// <summary>
+ /// Property for width component of Size
/// </summary>
public int Width
{
}
/// <summary>
+ /// Property for height component of Size
/// </summary>
public int Height
{
}
/// <summary>
+ /// Type cast operator, Size2D to Vector2.
/// </summary>
+ /// <param name="size">Object of 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.
/// </summary>
+ /// <param name="vec">Object of Vector2 type</param>
public static implicit operator Size2D(Vector2 vec)
{
return new Size2D((int)vec.X, (int)vec.Y);
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// Dispose
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
/// <summary>
- /// Emitted when the slider value changes.
+ /// Value changed event arguments.
/// </summary>
public class ValueChangedEventArgs : EventArgs
{
private Slider _slider;
private float _slideValue;
+ /// <summary>
+ /// Slider.
+ /// </summary>
public Slider Slider
{
get
}
}
+ /// <summary>
+ /// Slider value.
+ /// </summary>
public float SlideValue
{
get
}
/// <summary>
- /// Emitted when the sliding is finished.
+ /// Sliding finished event arguments.
/// </summary>
public class SlidingFinishedEventArgs : EventArgs
{
private Slider _slider;
private float _slideValue;
+ /// <summary>
+ /// Slider.
+ /// </summary>
public Slider Slider
{
get
}
}
+ /// <summary>
+ /// Slider value.
+ /// </summary>
public float SlideValue
{
get
}
/// <summary>
- /// Emitted when the slider handle reaches a mark.
+ /// Mark reached event arguments.
/// </summary>
public class MarkReachedEventArgs : EventArgs
{
private Slider _slider;
private int _slideValue;
+ /// <summary>
+ /// Slider.
+ /// </summary>
public Slider Slider
{
get
}
}
+ /// <summary>
+ /// Slider value.
+ /// </summary>
public int SlideValue
{
get
private MarkReachedCallbackDelegate _sliderMarkReachedCallbackDelegate;
/// <summary>
+ /// Event emitted when the slider value changes.
/// </summary>
public event EventHandlerWithReturnType<object, ValueChangedEventArgs, bool> ValueChanged
{
}
/// <summary>
+ /// Event emitted when the sliding is finished.
/// </summary>
public event EventHandlerWithReturnType<object, SlidingFinishedEventArgs, bool> SlidingFinished
{
}
/// <summary>
+ /// Event emitted when the slider handle reaches a mark.
/// </summary>
public event EventHandlerWithReturnType<object, MarkReachedEventArgs, bool> MarkReached
{
}
/// <summary>
+ /// Get Slider from the pointer.
/// </summary>
+ /// <param name="cPtr">The pointer of Slider</param>
+ /// <returns>Object of Slider type</returns>
public static Slider GetSliderFromPtr(global::System.IntPtr cPtr)
{
Slider ret = new Slider(cPtr, false);
}
/// <summary>
- /// Creates an empty Slider handle.
+ /// Creates the Slider control.
/// </summary>
public Slider() : this(NDalicPINVOKE.Slider_New(), true)
{
/// If handle points to a Slider, the downcast produces valid handle.
/// If not, the returned handle is left uninitialized.
/// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to a Slider or an uninitialized handle</returns>
public new static Slider DownCast(BaseHandle handle)
{
Slider ret = new Slider(NDalicPINVOKE.Slider_DownCast(BaseHandle.getCPtr(handle)), true);
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// Dispose.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
/// <summary>
- /// Touch event argument
+ /// Touch event argument.
/// </summary>
public class TouchEventArgs : EventArgs
{
private Touch _touch;
/// <summary>
- /// Touch
+ /// Touch.
/// </summary>
public Touch Touch
{
}
/// <summary>
- /// Wheel event arguments
+ /// Wheel event arguments.
/// </summary>
public class WheelEventArgs : EventArgs
{
private Wheel _wheel;
/// <summary>
- /// Wheel
+ /// Wheel.
/// </summary>
public Wheel Wheel
{
private EventCallbackDelegateType1 _stageWheelCallbackDelegate;
/// <summary>
- /// This is emitted when wheel event is received.
+ /// Event emitted when wheel event is received.
/// </summary>
public event EventHandler<WheelEventArgs> Wheel
{
private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
/// <summary>
- /// This is emitted when key event is received.
+ /// Event emitted when key event is received.
/// </summary>
public event EventHandler<KeyEventArgs> Key
{
}
/// <summary>
- /// Size.
+ /// Stage size property (read-only).
/// </summary>
public Size2D Size
{
}
/// <summary>
- /// Background color.
+ /// Background color property.
/// </summary>
public Color BackgroundColor
{
}
/// <summary>
- /// Dpi.
+ /// Dpi property (read-only).
+ /// Retrieves the DPI of the display device to which the stage is connected.
/// </summary>
public Vector2 Dpi
{
}
/// <summary>
- /// Layer count.
+ /// Layer count property (read-only).
+ /// Queries the number of on-stage layers.
/// </summary>
public uint LayerCount
{
private static readonly Stage instance = Stage.GetCurrent();
/// <summary>
- /// Stage instance.
+ /// Stage instance property (read-only).
+ /// Gets the current Stage.
/// </summary>
public static Stage Instance
{
/// <summary>
/// Get default ( root ) layer.
/// </summary>
+ /// <returns>The root layer</returns>
public Layer GetDefaultLayer()
{
return this.GetRootLayer();
/// <summary>
/// Add layer to the Stage.
/// </summary>
+ /// <param name="layer">Layer to add</param>
public void AddLayer(Layer layer)
{
this.Add((Actor)layer);
/// <summary>
/// Remove layer from the Stage.
/// </summary>
+ /// <param name="layer">Layer to remove</param>
public void RemoveLayer(Layer layer)
{
this.Remove((Actor)layer);
/// <summary>
/// Retrieves the layer at a specified depth.
/// </summary>
+ /// <param name="depth">The depth</param>
+ /// <returns>The layer found at the given depth</returns>
public Layer GetLayer(uint depth)
{
Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(swigCPtr, depth), true);
/// <summary>
/// Keep rendering for at least the given amount of time.
/// </summary>
+ /// <param name="durationSeconds">Time to keep rendering, 0 means render at least one more frame</param>
public void KeepRendering(float durationSeconds)
{
NDalicPINVOKE.Stage_KeepRendering(swigCPtr, durationSeconds);
/// <summary>
/// Gets the singleton of StyleManager object.
/// </summary>
+ /// <returns>A handle to the StyleManager control</returns>
public static StyleManager Get()
{
StyleManager ret = new StyleManager(NDalicPINVOKE.StyleManager_Get(), true);
/// application uses, then the default Toolkit theme will be used
/// instead for those controls.
/// </summary>
+ /// <param name="themeFile">A relative path is specified for style theme</param>
public void ApplyTheme(string themeFile)
{
NDalicPINVOKE.StyleManager_ApplyTheme(swigCPtr, themeFile);
/// <summary>
/// Sets a constant for use when building styles.
/// </summary>
+ /// <param name="key">The key of the constant</param>
+ /// <param name="value">The value of the constant</param>
public void SetStyleConstant(string key, PropertyValue value)
{
NDalicPINVOKE.StyleManager_SetStyleConstant(swigCPtr, key, PropertyValue.getCPtr(value));
/// <summary>
/// Returns the style constant set for a specific key.
/// </summary>
+ /// <param name="key">The key of the constant</param>
+ /// <param name="valueOut">The value of the constant if it exists</param>
+ /// <returns></returns>
public bool GetStyleConstant(string key, PropertyValue valueOut)
{
bool ret = NDalicPINVOKE.StyleManager_GetStyleConstant(swigCPtr, key, PropertyValue.getCPtr(valueOut));
/// <summary>
/// Applies the specified style to the control.
/// </summary>
+ /// <param name="control">The control to which to apply the style</param>
+ /// <param name="jsonFileName">The name of the JSON style file to apply</param>
+ /// <param name="styleName">The name of the style within the JSON file to apply</param>
public void ApplyStyle(View control, string jsonFileName, string styleName)
{
NDalicPINVOKE.StyleManager_ApplyStyle(swigCPtr, View.getCPtr(control), jsonFileName, styleName);
namespace Tizen.NUI
{
+
/// <summary>
/// TableView is a layout container for aligning child actors in a grid like layout.
/// TableView constrains the x and y position and width and height of the child actors.
DisposeQueue.Instance.Add(this);
}
- /// <summary>
- /// Dispose.
- /// <summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
/// <summary>
- /// Class to specify layout position for child actor.
+ /// Class to specify layout position for child view.
/// </summary>
public class CellPosition : global::System.IDisposable
{
Dispose();
}
- /// <summary>
- /// Dispose
- /// </summary>
public virtual void Dispose()
{
lock (this)
/// <summary>
/// Constructor.
/// </summary>
+ /// <param name="rowIndex">The row index initialized</param>
+ /// <param name="columnIndex">The column index initialized</param>
+ /// <param name="rowSpan">The row span initialized</param>
+ /// <param name="columnSpan">The column span initialized</param>
public CellPosition(uint rowIndex, uint columnIndex, uint rowSpan, uint columnSpan) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_0(rowIndex, columnIndex, rowSpan, columnSpan), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Constructor.
+ /// Constructor to initialise values to defaults for convenience.
/// </summary>
+ /// <param name="rowIndex">The row index initialized</param>
+ /// <param name="columnIndex">The column index initialized</param>
+ /// <param name="rowSpan">The row span initialized</param>
public CellPosition(uint rowIndex, uint columnIndex, uint rowSpan) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_1(rowIndex, columnIndex, rowSpan), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Constructor.
+ /// Constructor to initialise values to defaults for convenience.
/// </summary>
+ /// <param name="rowIndex">The row index initialized</param>
+ /// <param name="columnIndex">The column index initialized</param>
public CellPosition(uint rowIndex, uint columnIndex) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_2(rowIndex, columnIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Constructor.
+ /// Constructor to initialise values to defaults for convenience.
/// </summary>
+ /// <param name="rowIndex">The row index initialized</param>
public CellPosition(uint rowIndex) : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_3(rowIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Constructor to initialise values to defaults for convenience.
+ /// Default constructor
/// </summary>
public CellPosition() : this(NDalicPINVOKE.new_TableView_CellPosition__SWIG_4(), true)
{
}
/// <summary>
- /// Row index.
+ /// Index of row
/// </summary>
public uint rowIndex
{
}
/// <summary>
- /// Column index.
+ /// Index of column
/// </summary>
public uint columnIndex
{
}
/// <summary>
- /// Row span.
+ /// Span of row
/// </summary>
public uint rowSpan
{
}
/// <summary>
- /// Column span.
+ /// Span of column
/// </summary>
public uint columnSpan
{
}
/// <summary>
- /// Creates the TableView control.
+ /// Creates the TableView view.
/// </summary>
+ /// <param name="initialRows">initialRows for the table</param>
+ /// <param name="initialColumns">initialColumns for the table</param>
public TableView(uint initialRows, uint initialColumns) : this(NDalicPINVOKE.TableView_New(initialRows, initialColumns), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
/// <summary>
/// Copy constructor. Creates another handle that points to the same real object.
/// </summary>
+ /// <param name="handle">Handle to copy from</param>
public TableView(TableView handle) : this(NDalicPINVOKE.new_TableView__SWIG_1(TableView.getCPtr(handle)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
/// <summary>
/// Changes this handle to point to another real object.
/// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>A reference to this</returns>
public TableView Assign(TableView handle)
{
TableView ret = new TableView(NDalicPINVOKE.TableView_Assign(swigCPtr, TableView.getCPtr(handle)), false);
/// <summary>
/// Downcasts a handle to TableView handle.
+ /// If handle points to a TableView, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
/// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to a TableView or an uninitialized handle</returns>
public new static TableView DownCast(BaseHandle handle)
{
TableView ret = new TableView(NDalicPINVOKE.TableView_DownCast(BaseHandle.getCPtr(handle)), true);
/// <summary>
/// Adds a child to the table.
+ /// If the row or column index is outside the table, the table gets resized bigger.
/// </summary>
+ /// <param name="child">The child to add</param>
+ /// <param name="position">The position for the child</param>
+ /// <returns>Tue if the addition succeeded and false if the cell is already occupied</returns>
public bool AddChild(Actor child, TableView.CellPosition position)
{
bool ret = NDalicPINVOKE.TableView_AddChild(swigCPtr, Actor.getCPtr(child), TableView.CellPosition.getCPtr(position));
/// <summary>
/// Returns a child from the given layout position.
/// </summary>
+ /// <param name="position">The position in the table</param>
+ /// <returns>Child that was in the cell or an uninitialized handle</returns>
public Actor GetChildAt(TableView.CellPosition position)
{
Actor ret = new Actor(NDalicPINVOKE.TableView_GetChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
/// <summary>
/// Removes a child from the given layout position.
/// </summary>
+ /// <param name="position">The position for the child to remove</param>
+ /// <returns>Child that was removed or an uninitialized handle</returns>
public Actor RemoveChildAt(TableView.CellPosition position)
{
Actor ret = new Actor(NDalicPINVOKE.TableView_RemoveChildAt(swigCPtr, TableView.CellPosition.getCPtr(position)), true);
/// <summary>
/// Finds the child's layout position.
/// </summary>
+ /// <param name="child">The child to search for</param>
+ /// <param name="position">The position for the child</param>
+ /// <returns>true if the child was included in this TableView</returns>
public bool FindChildPosition(Actor child, TableView.CellPosition position)
{
bool ret = NDalicPINVOKE.TableView_FindChildPosition(swigCPtr, Actor.getCPtr(child), TableView.CellPosition.getCPtr(position));
/// <summary>
/// Inserts a new row to given index.
/// </summary>
+ /// <param name="rowIndex">The rowIndex of the new row</param>
public void InsertRow(uint rowIndex)
{
NDalicPINVOKE.TableView_InsertRow(swigCPtr, rowIndex);
/// <summary>
/// Deletes a row from the given index.
+ /// Removed elements are deleted.
/// </summary>
+ /// <param name="rowIndex">The rowIndex of the row to delete</param>
public void DeleteRow(uint rowIndex)
{
NDalicPINVOKE.TableView_DeleteRow__SWIG_0(swigCPtr, rowIndex);
/// <summary>
/// Inserts a new column to the given index.
/// </summary>
+ /// <param name="columnIndex">The columnIndex of the new column</param>
public void InsertColumn(uint columnIndex)
{
NDalicPINVOKE.TableView_InsertColumn(swigCPtr, columnIndex);
/// <summary>
/// Deletes a column from the given index.
+ /// Removed elements are deleted.
/// </summary>
+ /// <param name="columnIndex">The columnIndex of the column to delete</param>
public void DeleteColumn(uint columnIndex)
{
NDalicPINVOKE.TableView_DeleteColumn__SWIG_0(swigCPtr, columnIndex);
/// <summary>
/// Resizes the TableView.
/// </summary>
+ /// <param name="rows">The rows for the table</param>
+ /// <param name="columns">The columns for the table</param>
public void Resize(uint rows, uint columns)
{
NDalicPINVOKE.TableView_Resize__SWIG_0(swigCPtr, rows, columns);
/// <summary>
/// Sets horizontal and vertical padding between cells.
/// </summary>
+ /// <param name="padding">Width and height</param>
public void SetCellPadding(Size2D padding)
{
NDalicPINVOKE.TableView_SetCellPadding(swigCPtr, Size2D.getCPtr(padding));
/// <summary>
/// Gets the current padding as width and height.
/// </summary>
+ /// <returns>The current padding as width and height</returns>
public Vector2 GetCellPadding()
{
Vector2 ret = new Vector2(NDalicPINVOKE.TableView_GetCellPadding(swigCPtr), true);
/// <summary>
/// Specifies this row as fitting its height to its children.
/// </summary>
+ /// <param name="rowIndex">The row to set</param>
public void SetFitHeight(uint rowIndex)
{
NDalicPINVOKE.TableView_SetFitHeight(swigCPtr, rowIndex);
/// <summary>
/// Checks if the row is a fit row.
/// </summary>
+ /// <param name="rowIndex">The row to check</param>
+ /// <returns>true if the row is fit</returns>
public bool IsFitHeight(uint rowIndex)
{
bool ret = NDalicPINVOKE.TableView_IsFitHeight(swigCPtr, rowIndex);
/// <summary>
/// Specifies this column as fitting its width to its children.
/// </summary>
+ /// <param name="columnIndex">The column to set</param>
public void SetFitWidth(uint columnIndex)
{
NDalicPINVOKE.TableView_SetFitWidth(swigCPtr, columnIndex);
/// <summary>
/// Checks if the column is a fit column.
/// </summary>
+ /// <param name="columnIndex">The column to check</param>
+ /// <returns>true if the column is fit</returns>
public bool IsFitWidth(uint columnIndex)
{
bool ret = NDalicPINVOKE.TableView_IsFitWidth(swigCPtr, columnIndex);
/// <summary>
/// Sets a row to have fixed height.
+ /// Setting a fixed height of 0 has no effect.
/// </summary>
+ /// <param name="rowIndex">The rowIndex for row with fixed height</param>
+ /// <param name="height">The height in world coordinate units</param>
public void SetFixedHeight(uint rowIndex, float height)
{
NDalicPINVOKE.TableView_SetFixedHeight(swigCPtr, rowIndex, height);
/// <summary>
/// Gets a row's fixed height.
/// </summary>
+ /// <param name="rowIndex">The row index with fixed height</param>
+ /// <returns>height The height in world coordinate units</returns>
public float GetFixedHeight(uint rowIndex)
{
float ret = NDalicPINVOKE.TableView_GetFixedHeight(swigCPtr, rowIndex);
/// the remainder of the table height after subtracting Padding and Fixed height rows.
/// Setting a relative height of 0 has no effect.
/// </summary>
+ /// <param name="rowIndex">The rowIndex for row with relative height</param>
+ /// <param name="heightPercentage">The height percentage between 0.0f and 1.0f</param>
public void SetRelativeHeight(uint rowIndex, float heightPercentage)
{
NDalicPINVOKE.TableView_SetRelativeHeight(swigCPtr, rowIndex, heightPercentage);
/// <summary>
/// Gets a row's relative height.
/// </summary>
+ /// <param name="rowIndex">The row index with relative height</param>
+ /// <returns>Height in percentage units, between 0.0f and 1.0f</returns>
public float GetRelativeHeight(uint rowIndex)
{
float ret = NDalicPINVOKE.TableView_GetRelativeHeight(swigCPtr, rowIndex);
/// <summary>
/// Sets a column to have fixed width.
+ /// Setting a fixed width of 0 has no effect.
/// </summary>
+ /// <param name="columnIndex">The columnIndex for column with fixed width</param>
+ /// <param name="width">The width in world coordinate units</param>
public void SetFixedWidth(uint columnIndex, float width)
{
NDalicPINVOKE.TableView_SetFixedWidth(swigCPtr, columnIndex, width);
/// <summary>
/// Gets a column's fixed width.
/// </summary>
+ /// <param name="columnIndex">The column index with fixed width</param>
+ /// <returns>Width in world coordinate units</returns>
public float GetFixedWidth(uint columnIndex)
{
float ret = NDalicPINVOKE.TableView_GetFixedWidth(swigCPtr, columnIndex);
/// the remainder of table width after subtracting Padding and Fixed width columns.
/// Setting a relative width of 0 has no effect.
/// </summary>
+ /// <param name="columnIndex">The columnIndex for column with fixed width</param>
+ /// <param name="widthPercentage">The widthPercentage between 0.0f and 1.0f</param>
public void SetRelativeWidth(uint columnIndex, float widthPercentage)
{
NDalicPINVOKE.TableView_SetRelativeWidth(swigCPtr, columnIndex, widthPercentage);
/// <summary>
/// Gets a column's relative width.
/// </summary>
+ /// <param name="columnIndex">The column index with relative width</param>
+ /// <returns>Width in percentage units, between 0.0f and 1.0f</returns>
public float GetRelativeWidth(uint columnIndex)
{
float ret = NDalicPINVOKE.TableView_GetRelativeWidth(swigCPtr, columnIndex);
/// <summary>
/// Gets the amount of rows in the table.
/// </summary>
+ /// <returns>The amount of rows in the table</returns>
public uint GetRows()
{
uint ret = NDalicPINVOKE.TableView_GetRows(swigCPtr);
/// <summary>
/// Gets the amount of columns in the table.
/// </summary>
+ /// <returns>The amount of columns in the table</returns>
public uint GetColumns()
{
uint ret = NDalicPINVOKE.TableView_GetColumns(swigCPtr);
/// <summary>
/// Sets the alignment on a cell.
+ /// Cells without calling this function have the default values of LEFT and TOP respectively.
/// </summary>
+ /// <param name="position">The cell to set alignment on</param>
+ /// <param name="horizontal">The horizontal alignment</param>
+ /// <param name="vertical">The vertical alignment</param>
public void SetCellAlignment(TableView.CellPosition position, HorizontalAlignmentType horizontal, VerticalAlignmentType vertical)
{
NDalicPINVOKE.TableView_SetCellAlignment(swigCPtr, TableView.CellPosition.getCPtr(position), (int)horizontal, (int)vertical);
}
/// <summary>
- /// Layout policy.
+ /// Enumeration for describing how the size of a row / column has been set.
/// </summary>
public enum LayoutPolicy
{
}
/// <summary>
- /// Rows property.
+ /// the amount of rows in the table.
/// </summary>
public int Rows
{
SetProperty(TableView.Property.ROWS, new Tizen.NUI.PropertyValue(value));
}
}
-
/// <summary>
- /// Columns property.
+ /// the amount of columns in the table.
/// </summary>
public int Columns
{
SetProperty(TableView.Property.COLUMNS, new Tizen.NUI.PropertyValue(value));
}
}
-
/// <summary>
- /// Cell padding property.
+ /// padding between cells.
/// </summary>
public Vector2 CellPadding
{
}
/// <summary>
- /// Layout rows property.
+ /// The number of layout rows
/// </summary>
public PropertyMap LayoutRows
{
}
/// <summary>
- /// Layout columns property.
+ /// The number of layout columns
/// </summary>
public PropertyMap LayoutColumns
{
}
/// <summary>
- /// HorizontalAlignmentType.
+ /// Enumeration for horizontal alignment types.
/// </summary>
public enum HorizontalAlignmentType
{
}
/// <summary>
- /// VerticalAlignmentType.
+ /// Enumeration for vertical alignment types.
/// </summary>
public enum VerticalAlignmentType
{
/// <summary>
- /// Get TapGesture from Ptr.
+ /// Get TapGesture from the pointer.
/// </summary>
+ /// <param name="cPtr">The pointer to cast</param>
+ /// <returns>TapGesture object</returns>
public static TapGesture GetTapGestureFromPtr(global::System.IntPtr cPtr)
{
TapGesture ret = new TapGesture(cPtr, false);
}
/// <summary>
- /// NumberOfTaps.
+ /// Number of taps property (read-only).
/// </summary>
public uint NumberOfTaps
{
}
/// <summary>
- /// NumberOfTouches.
+ /// Number of touches property (read-only).
/// </summary>
public uint NumberOfTouches
{
}
/// <summary>
- /// ScreenPoint.
+ /// Screen point property (read-only).
/// </summary>
public Vector2 ScreenPoint
{
}
/// <summary>
- /// LocalPoint.
+ /// Local point property (read-only).
/// </summary>
public Vector2 LocalPoint
{
}
/// <summary>
- /// Default constructor.
+ /// Creates a TapGesture.
/// </summary>
public TapGesture() : this(NDalicPINVOKE.new_TapGesture__SWIG_0(), true)
{
/// <summary>
/// Copy constructor.
/// </summary>
+ /// <param name="rhs">TapGesture to copy</param>
public TapGesture(TapGesture rhs) : this(NDalicPINVOKE.new_TapGesture__SWIG_1(TapGesture.getCPtr(rhs)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// <summary>
- /// Assignment.
+ /// Assignment
/// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
public TapGesture Assign(TapGesture rhs)
{
TapGesture ret = new TapGesture(NDalicPINVOKE.TapGesture_Assign(swigCPtr, TapGesture.getCPtr(rhs)), false);
}
/// <summary>
- /// Creates an empty handle.
+ /// Creates the TextEditor control.
/// </summary>
public TextEditor() : this(NDalicPINVOKE.TextEditor_New(), true)
{
/// <summary>
/// Downcasts a handle to TextEditor.
/// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to a TextEditor or an empty handle</returns>
public new static TextEditor DownCast(BaseHandle handle)
{
TextEditor ret = new TextEditor(NDalicPINVOKE.TextEditor_DownCast(BaseHandle.getCPtr(handle)), true);
}
/// <summary>
- /// Creates an empty handle.
+ /// Creates the TextField control.
/// </summary>
public TextField() : this(NDalicPINVOKE.TextField_New(), true)
{
/// <summary>
/// Downcasts a handle to TextField.
/// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to a TextField or an empty handle</returns>
public new static TextField DownCast(BaseHandle handle)
{
TextField ret = new TextField(NDalicPINVOKE.TextField_DownCast(BaseHandle.getCPtr(handle)), true);
namespace Tizen.NUI
{
+ /// <summary>
+ /// A control which renders a short text string.
+ /// Text labels are lightweight, non-editable and do not respond to user input.
+ /// </summary>
public class TextLabel : View
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// Dispose
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
+ /// <summary>
+ /// Creates the TextLabel control.
+ /// </summary>
public TextLabel() : this(NDalicPINVOKE.TextLabel_New__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Creates the TextLabel control.
+ /// </summary>
+ /// <param name="text">The text to display</param>
public TextLabel(string text) : this(NDalicPINVOKE.TextLabel_New__SWIG_1(text), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to TextLabel.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
public new static TextLabel DownCast(BaseHandle handle)
{
TextLabel ret = new TextLabel(NDalicPINVOKE.TextLabel_DownCast(BaseHandle.getCPtr(handle)), true);
PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
}
+ /// <summary>
+ /// RenderingBackend property
+ /// The type of rendering e.g. bitmap-based.
+ /// </summary>
public int RenderingBackend
{
get
SetProperty(TextLabel.Property.RENDERING_BACKEND, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Text property
+ /// The text to display in UTF-8 format.
+ /// </summary>
public string Text
{
get
SetProperty(TextLabel.Property.TEXT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// FontFamily property
+ /// The requested font family to use.
+ /// </summary>
public string FontFamily
{
get
SetProperty(TextLabel.Property.FONT_FAMILY, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// FontStyle property
+ /// The requested font style to use.
+ /// </summary>
public PropertyMap FontStyle
{
get
SetProperty(TextLabel.Property.FONT_STYLE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// PointSize property
+ /// The size of font in points.
+ /// </summary>
public float PointSize
{
get
SetProperty(TextLabel.Property.POINT_SIZE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// MultiLine property
+ /// The single-line or multi-line layout option.
+ /// </summary>
public bool MultiLine
{
get
SetProperty(TextLabel.Property.MULTI_LINE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// HorizontalAlignment property
+ /// The line horizontal alignment.
+ /// </summary>
public string HorizontalAlignment
{
get
SetProperty(TextLabel.Property.HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// VerticalAlignment property
+ /// The line vertical alignment.
+ /// </summary>
public string VerticalAlignment
{
get
SetProperty(TextLabel.Property.VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// TextColor property
+ /// The color of the text.
+ /// </summary>
public Color TextColor
{
get
SetProperty(TextLabel.Property.TEXT_COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// ShadowOffset property
+ /// The drop shadow offset 0 indicates no shadow.
+ /// </summary>
public Vector2 ShadowOffset
{
get
SetProperty(TextLabel.Property.SHADOW_OFFSET, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// ShadowColor property
+ /// The color of a drop shadow.
+ /// </summary>
public Vector4 ShadowColor
{
get
SetProperty(TextLabel.Property.SHADOW_COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// UnderlineEnabled property
+ /// The underline enabled flag.
+ /// </summary>
public bool UnderlineEnabled
{
get
SetProperty(TextLabel.Property.UNDERLINE_ENABLED, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// UnderlineColor property
+ /// Overrides the underline height from font metrics.
+ /// </summary>
public Vector4 UnderlineColor
{
get
SetProperty(TextLabel.Property.UNDERLINE_COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// UnderlineHeight property
+ /// Overrides the underline height from font metrics.
+ /// </summary>
public float UnderlineHeight
{
get
SetProperty(TextLabel.Property.UNDERLINE_HEIGHT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// EnableMarkup property
+ /// Whether the mark-up processing is enabled.
+ /// </summary>
public bool EnableMarkup
{
get
SetProperty(TextLabel.Property.ENABLE_MARKUP, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// EnableAutoScroll property
+ /// Starts or stops auto scrolling.
+ /// </summary>
public bool EnableAutoScroll
{
get
SetProperty(TextLabel.Property.ENABLE_AUTO_SCROLL, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// AutoScrollSpeed property
+ /// Sets the speed of scrolling in pixels per second.
+ /// </summary>
public int AutoScrollSpeed
{
get
SetProperty(TextLabel.Property.AUTO_SCROLL_SPEED, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// AutoScrollLoopCount property
+ /// Number of complete loops when scrolling enabled.
+ /// </summary>
public int AutoScrollLoopCount
{
get
SetProperty(TextLabel.Property.AUTO_SCROLL_LOOP_COUNT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// AutoScrollGap property
+ /// Gap before scrolling wraps.
+ /// </summary>
public float AutoScrollGap
{
get
SetProperty(TextLabel.Property.AUTO_SCROLL_GAP, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// LineSpacing property
+ /// The default extra space between lines in points.
+ /// </summary>
public float LineSpacing
{
get
SetProperty(TextLabel.Property.LINE_SPACING, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Underline property
+ /// The default underline parameters.
+ /// </summary>
public PropertyMap Underline
{
get
SetProperty(TextLabel.Property.UNDERLINE, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Shadow property
+ /// The default shadow parameters.
+ /// </summary>
public PropertyMap Shadow
{
get
SetProperty(TextLabel.Property.SHADOW, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Emboss property
+ /// The default emboss parameters.
+ /// </summary>
public PropertyMap Emboss
{
get
SetProperty(TextLabel.Property.EMBOSS, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Outline property
+ /// The default outline parameters.
+ /// </summary>
public PropertyMap Outline
{
get
projects / platform / core / csapi / tizenfx.git / commitdiff