using System.Runtime.InteropServices;
+ /// <summary>
+ /// The Popup widget provides a configurable pop-up dialog with built-in layout of three main fields.
+ /// </summary>
public class Popup : View
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ /// <summary>
+ /// Event arguments that passed via OutsideTouchedEvent
+ /// </summary>
public class OutsideTouchedEventArgs : EventArgs
{
}
+ /// <summary>
+ /// Event arguments that passed via ShowingEventArgs
+ /// </summary>
public class ShowingEventArgs : EventArgs
{
}
+ /// <summary>
+ /// Event arguments that passed via ShownEventArgs
+ /// </summary>
public class ShownEventArgs : EventArgs
{
}
+ /// <summary>
+ /// Event arguments that passed via HidingEventArgs
+ /// </summary>
public class HidingEventArgs : EventArgs
{
}
+ /// <summary>
+ /// Event arguments that passed via HiddenEventArgs
+ /// </summary>
public class HiddenEventArgs : EventArgs
{
}
private EventHandler<HiddenEventArgs> _popUpHiddenEventHandler;
private HiddenEventCallbackDelegate _popUpHiddenEventCallbackDelegate;
+ /// <summary>
+ /// Event is sent when user has touched outside of the Dialog.
+ /// </summary>
public event EventHandler<OutsideTouchedEventArgs> OutsideTouched
{
add
}
}
+ /// <summary>
+ /// Event is sent when the Popup is starting to be shown.
+ /// </summary>
public event EventHandler<ShowingEventArgs> Showing
{
add
}
+ /// <summary>
+ /// Event is sent when the Popup has been fully displayed.
+ /// </summary>
public event EventHandler<ShownEventArgs> Shown
{
add
}
}
+ /// <summary>
+ /// Event is sent when the Popup is starting to be hidden.
+ /// </summary>
public event EventHandler<HidingEventArgs> Hiding
{
add
}
}
+ /// <summary>
+ /// Event is sent when the Popup has been completely hidden.
+ /// </summary>
public event EventHandler<HiddenEventArgs> Hidden
{
add
}
+ /// <summary>
+ /// Create the Popup.
+ /// </summary>
public Popup() : this(NDalicPINVOKE.Popup_New(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to Popup handle.
+ /// If handle points to a Popup, 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 Popup or an uninitialized handle</returns>
public new static Popup DownCast(BaseHandle handle)
{
Popup ret = new Popup(NDalicPINVOKE.Popup_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Sets a title for this Popup.
+ /// </summary>
+ /// <param name="titleActor">The actor to set a title</param>
public void SetTitle(Actor titleActor)
{
NDalicPINVOKE.Popup_SetTitle(swigCPtr, Actor.getCPtr(titleActor));
return ret;
}
+ /// <summary>
+ /// Sets the content actor.
+ /// </summary>
+ /// <param name="content">The actor to use</param>
public void SetContent(Actor content)
{
NDalicPINVOKE.Popup_SetContent(swigCPtr, Actor.getCPtr(content));
return ret;
}
+ /// <summary>
+ /// Sets the actor to use for a footer in this Popup.
+ /// </summary>
+ /// <param name="footer">The footer actor to be added to this Popup</param>
public void SetFooter(Actor footer)
{
NDalicPINVOKE.Popup_SetFooter(swigCPtr, Actor.getCPtr(footer));
return ret;
}
+ /// <summary>
+ /// Sets the display state of Popup.
+ /// There are 4 total display states.
+ /// Only 2 can be set, but all four can be read for better inspection of the current popup state.
+ ///
+ /// The other two states are getable, but not setable and are there for consistency.
+ ///
+ /// | Value | Setting the state | Getting the state |
+ /// |----------|--------------------------------|--------------------------------|
+ /// | SHOWN | Show the popup | The popup is fully shown |
+ /// | HIDDEN | Hide the popup | The popup is fully hidden |
+ /// | SHOWING | | The popup is transitioning in |
+ /// | HIDING | | The popup is transitioning out |
+ ///
+ /// All 4 state changes cause notifications via 4 respective signals that can be connected to.
+ /// </summary>
+ /// <param name="displayState">The desired display state to change to</param>
public void SetDisplayState(Popup.DisplayStateType displayState)
{
NDalicPINVOKE.Popup_SetDisplayState(swigCPtr, (int)displayState);
PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
}
+ /// <summary>
+ /// The display states of the Popup.
+ /// </summary>
public enum DisplayStateType
{
Showing,
Hidden
}
+ /// <summary>
+ /// The animation mode within popup.
+ /// Choose from a predefined mode or "CUSTOM" to use the ANIMATION_IN and ANIMATION_OUT properties.
+ /// </summary>
public enum AnimationModeType
{
None,
Custom
}
+ /// <summary>
+ /// Types of contextual layout.
+ /// The Popup is positioned adjacent to it's parent in the direction specified by this mode.
+ /// NON_CONTEXTUAL disables any contextual positioning.
+ /// </summary>
public enum ContextualModeType
{
NonContextual,
Left
}
+ /// <summary>
+ /// Popup title
+ /// </summary>
public PropertyMap Title
{
get
SetProperty(Popup.Property.TITLE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Popup content
+ /// </summary>
public PropertyMap Content
{
get
SetProperty(Popup.Property.CONTENT, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Popup footer
+ /// </summary>
public PropertyMap Footer
{
get
SetProperty(Popup.Property.FOOTER, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Popup display state
+ /// </summary>
public string DisplayState
{
get
SetProperty(Popup.Property.DISPLAY_STATE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Touch transparent
+ /// </summary>
public bool TouchTransparent
{
get
SetProperty(Popup.Property.TOUCH_TRANSPARENT, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Popup tail visibility
+ /// </summary>
public bool TailVisibility
{
get
SetProperty(Popup.Property.TAIL_VISIBILITY, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Popup tail position
+ /// </summary>
public Vector3 TailPosition
{
get
SetProperty(Popup.Property.TAIL_POSITION, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Contextual mode
+ /// </summary>
public string ContextualMode
{
get
SetProperty(Popup.Property.CONTEXTUAL_MODE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Animation duration
+ /// </summary>
public float AnimationDuration
{
get
SetProperty(Popup.Property.ANIMATION_DURATION, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Animation mode
+ /// </summary>
public string AnimationMode
{
get
SetProperty(Popup.Property.ANIMATION_MODE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Entry animation
+ /// </summary>
public PropertyMap EntryAnimation
{
get
SetProperty(Popup.Property.ENTRY_ANIMATION, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Exit animation
+ /// </summary>
public PropertyMap ExitAnimation
{
get
SetProperty(Popup.Property.EXIT_ANIMATION, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Auto hide delay
+ /// </summary>
public int AutoHideDelay
{
get
SetProperty(Popup.Property.AUTO_HIDE_DELAY, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Backing enabled
+ /// </summary>
public bool BackingEnabled
{
get
SetProperty(Popup.Property.BACKING_ENABLED, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Backing color
+ /// </summary>
public Vector4 BackingColor
{
get
SetProperty(Popup.Property.BACKING_COLOR, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Background image
+ /// </summary>
public string PopupBackgroundImage
{
get
SetProperty(Popup.Property.POPUP_BACKGROUND_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Background border
+ /// </summary>
public Rectangle PopupBackgroundBorder
{
get
SetProperty(Popup.Property.POPUP_BACKGROUND_BORDER, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Tail up image
+ /// </summary>
public string TailUpImage
{
get
SetProperty(Popup.Property.TAIL_UP_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Tail down image
+ /// </summary>
public string TailDownImage
{
get
SetProperty(Popup.Property.TAIL_DOWN_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Tail left image
+ /// </summary>
public string TailLeftImage
{
get
SetProperty(Popup.Property.TAIL_LEFT_IMAGE, new Tizen.NUI.PropertyValue(value));
}
}
+ /// <summary>
+ /// Tail right image
+ /// </summary>
public string TailRightImage
{
get
namespace Tizen.NUI {
+/// <summary>
+/// Position is a three dimensional vector.
+/// </summary>
public class Position : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
+ /// <param name="arg1">Vector to add</param>
+ /// <param name="arg2">Vector to add</param>
+ /// <returns>A vector containing the result of the addition</returns>
public static Position operator+(Position arg1, Position arg2) {
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
+ /// <param name="arg1">Vector to subtract</param>
+ /// <param name="arg2">Vector to subtract</param>
+ /// <returns>A vector containing the result of the subtraction</returns>
public static Position operator-(Position arg1, Position arg2) {
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Unary negation operator.
+ /// </summary>
+ /// <param name="arg1">Vector to netate</param>
+ /// <returns>A vector containg the negation</returns>
public static Position operator-(Position arg1) {
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">The vector to multiply</param>
+ /// <param name="arg2">The vector to multiply</param>
+ /// <returns>A vector containing the result of the multiplication</returns>
public static Position operator*(Position arg1, Position arg2) {
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">The vector to multiply</param>
+ /// <param name="arg2">The float value to scale the vector</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Position operator*(Position arg1, float arg2) {
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">The vector to divide</param>
+ /// <param name="arg2">The vector to divide</param>
+ /// <returns>A vector containing the result of the division</returns>
public static Position operator/(Position arg1, Position arg2) {
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">The vector to divide</param>
+ /// <param name="arg2">The float value to scale the vector by</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Position operator/(Position arg1, float arg2) {
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Const array subscript operator overload. Should be 0, 1 or 2.
+ /// </summary>
+ /// <param name="index">Subscript index</param>
+ /// <returns>The float at the given index</returns>
public float this[uint index]
{
get
}
}
+ /// <summary>
+ /// </summary>
public static Position GetPositionFromPtr(global::System.IntPtr cPtr) {
Position ret = new Position(cPtr, false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="x">x component</param>
+ /// <param name="y">y component</param>
+ /// <param name="z">z component</param>
public Position(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="position2d">Position2D to create this vector from</param>
public Position(Position2D position2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
+ /// <summary>
+ /// Compare if rhs is equal to
+ /// </summary>
+ /// <param name="rhs">The vector to compare</param>
+ /// <returns>Returns true if the two vectors are equal, otherwise false</returns>
public bool EqualTo(Position rhs) {
bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Compare if rhs is not equal to
+ /// </summary>
+ /// <param name="rhs">The vector to compare</param>
+ /// <returns>Returns true if the two vectors are not equal, otherwise false</returns>
public bool NotEqualTo(Position rhs) {
bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// x component
+ /// </summary>
public float X {
set {
NDalicPINVOKE.Vector3_X_set(swigCPtr, value);
}
}
+ /// <summary>
+ /// y component
+ /// </summary>
public float Y {
set {
NDalicPINVOKE.Vector3_Y_set(swigCPtr, value);
}
}
+ /// <summary>
+ /// z component
+ /// </summary>
public float Z {
set {
NDalicPINVOKE.Vector3_Z_set(swigCPtr, value);
}
}
- public static float ParentOriginTop
- {
- get
- {
- float ret = NDalicPINVOKE.ParentOriginTop_get();
- if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
- return ret;
- }
- }
+ /// <summary>
+ /// ParentOrigin constants. It's 0.0.
+ /// </summary>
+ public static float ParentOriginTop
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.ParentOriginTop_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+ /// <summary>
+ /// ParentOrigin constants. It's 1.0.
+ /// </summary>
public static float ParentOriginBottom
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants. It's 0.0.
+ /// </summary>
public static float ParentOriginLeft
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants. It's 1.0.
+ /// </summary>
public static float ParentOriginRight
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants. It's 0.5.
+ /// </summary>
public static float ParentOriginMiddle
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 0.0, 0.0, 0.5
+ /// </summary>
public static Position ParentOriginTopLeft
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 0.5, 0.0, 0.5
+ /// </summary>
public static Position ParentOriginTopCenter
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 1.0, 0.0, 0.5
+ /// </summary>
public static Position ParentOriginTopRight
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 0.0, 0.5, 0.5
+ /// </summary>
public static Position ParentOriginCenterLeft
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 0.0, 0.5, 0.5
+ /// </summary>
public static Position ParentOriginCenter
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 1.0, 0.5, 0.5
+ /// </summary>
public static Position ParentOriginCenterRight
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 0.0f, 1.0f, 0.5f
+ /// </summary>
public static Position ParentOriginBottomLeft
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 0.5, 1.0, 0.5
+ /// </summary>
public static Position ParentOriginBottomCenter
{
get
}
}
+ /// <summary>
+ /// ParentOrigin constants: 1.0, 1.0, 0.5
+ /// </summary>
public static Position ParentOriginBottomRight
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.0
+ /// </summary>
public static float AnchorPointTop
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 1.0
+ /// </summary>
public static float AnchorPointBottom
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.0
+ /// </summary>
public static float AnchorPointLeft
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 1.0
+ /// </summary>
public static float AnchorPointRight
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.0
+ /// </summary>
public static float AnchorPointMiddle
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.0, 0.0, 0.5
+ /// </summary>
public static Position AnchorPointTopLeft
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.5, 0.0, 0.5
+ /// </summary>
public static Position AnchorPointTopCenter
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 1.0, 0.0, 0.5
+ /// </summary>
public static Position AnchorPointTopRight
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.0, 0.5, 0.5
+ /// </summary>
public static Position AnchorPointCenterLeft
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.5, 0.5, 0.5
+ /// </summary>
public static Position AnchorPointCenter
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 1.0, 0.5, 0.5
+ /// </summary>
public static Position AnchorPointCenterRight
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.0, 1.0, 0.5
+ /// </summary>
public static Position AnchorPointBottomLeft
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 0.5, 1.0, 0.5
+ /// </summary>
public static Position AnchorPointBottomCenter
{
get
}
}
+ /// <summary>
+ /// AnchorPoint constants: 1.0, 1.0, 0.5
+ /// </summary>
public static Position AnchorPointBottomRight
{
get
}
}
+ /// <summary>
+ /// Constant ( 1.0f, 1.0f, 1.0f )
+ /// </summary>
public static Position One {
get {
global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ONE_get();
}
}
+ /// <summary>
+ /// Constant ( 0.0f, 0.0f, 0.0f )
+ /// </summary>
public static Position Zero {
get {
global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZERO_get();
}
}
+ /// <summary>
+ /// </summary>
public static implicit operator Vector3(Position Position)
{
return new Vector3(Position.X, Position.Y, Position.Z);
}
+ /// <summary>
+ /// </summary>
public static implicit operator Position(Vector3 vec)
{
return new Position(vec.X, vec.Y, vec.Z);
}
+ /// <summary>
+ /// A Array of property values.
+ /// </summary>
public class PropertyArray : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
+ /// <summary>
+ /// Operator to access an element.
+ /// </summary>
+ /// <param name="index">The element index to access. No bounds checking is performed</param>
+ /// <returns>The a reference to the element</returns>
public PropertyValue this[uint index]
{
get
}
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
public PropertyArray() : this(NDalicPINVOKE.new_Property_Array__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves the number of elements in the array.
+ /// </summary>
+ /// <returns>The number of elements in the array</returns>
public uint Size()
{
uint ret = NDalicPINVOKE.Property_Array_Size(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Retrieves the number of elements in the array.
+ /// </summary>
+ /// <returns>The number of elements in the array</returns>
public uint Count()
{
uint ret = NDalicPINVOKE.Property_Array_Count(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns whether the array is empty.
+ /// </summary>
+ /// <returns>Return true if empty, false otherwise</returns>
public bool Empty()
{
bool ret = NDalicPINVOKE.Property_Array_Empty(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Clears the array.
+ /// </summary>
public void Clear()
{
NDalicPINVOKE.Property_Array_Clear(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Increases the capacity of the array.
+ /// </summary>
+ /// <param name="size">The size to reserve</param>
public void Reserve(uint size)
{
NDalicPINVOKE.Property_Array_Reserve(swigCPtr, size);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Resizes to size.
+ /// </summary>
+ /// <param name="size">The size to resize</param>
public void Resize(uint size)
{
NDalicPINVOKE.Property_Array_Resize(swigCPtr, size);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves the capacity of the array.
+ /// </summary>
+ /// <returns>The allocated capacity of the array</returns>
public uint Capacity()
{
uint ret = NDalicPINVOKE.Property_Array_Capacity(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Adds an element to the array.
+ /// </summary>
+ /// <param name="value">The value to add to the end of the array</param>
public void PushBack(PropertyValue value)
{
NDalicPINVOKE.Property_Array_PushBack(swigCPtr, PropertyValue.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Add an element to the array.
+ /// </summary>
+ /// <param name="value">The value to add to the end of the array</param>
public PropertyArray Add(PropertyValue value)
{
PropertyArray ret = new PropertyArray(NDalicPINVOKE.Property_Array_Add(swigCPtr, PropertyValue.getCPtr(value)), false);
return ret;
}
+ /// <summary>
+ /// Access an element.
+ /// </summary>
+ /// <param name="index">The element index to access. No bounds checking is performed</param>
+ /// <returns>The a reference to the element</returns>
public PropertyValue GetElementAt(uint index)
{
PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Array_GetElementAt__SWIG_0(swigCPtr, index), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the value of elements in the array.
+ /// </summary>
+ /// <param name="index">The element index to retrieve.</param>
+ /// <returns>The a reference to the element</returns>
public PropertyValue ValueOfIndex(uint index)
{
PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Array_ValueOfIndex__SWIG_0(swigCPtr, index), false);
return ret;
}
- public PropertyArray Assign(PropertyArray other)
+ /// <summary>
+ /// Copy the array.
+ /// </summary>
+ /// <param name="other">The array to copy from</param>
+ /// <returns>The copied array</returns>
+ internal PropertyArray Assign(PropertyArray other)
{
PropertyArray ret = new PropertyArray(NDalicPINVOKE.Property_Array_Assign(swigCPtr, PropertyArray.getCPtr(other)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// A key type which can be either a std::string or a Property::Index
+ /// </summary>
public class PropertyKey : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
+ /// <summary>
+ /// The type of the key
+ /// </summary>
public PropertyKey.Type type
{
set
}
}
+ /// <summary>
+ /// The index key.
+ /// </summary>
public int indexKey
{
set
}
}
+ /// <summary>
+ /// The string key.
+ /// </summary>
public string stringKey
{
set
}
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="key">The string key</param>
public PropertyKey(string key) : this(NDalicPINVOKE.new_Property_Key__SWIG_0(key), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="key">The index key</param>
public PropertyKey(int key) : this(NDalicPINVOKE.new_Property_Key__SWIG_1(key), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Compare if rhs is equal to
+ /// </summary>
+ /// <param name="rhs">A string key to compare against</param>
+ /// <returns>Returns true if the key compares, or false if it isn't equal or of the wrong type</returns>
public bool EqualTo(string rhs)
{
bool ret = NDalicPINVOKE.Property_Key_EqualTo__SWIG_0(swigCPtr, rhs);
return ret;
}
+ /// <summary>
+ /// Compare if rhs is equal to
+ /// </summary>
+ /// <param name="rhs">A index key to compare against</param>
+ /// <returns>Returns true if the key compares, or false if it isn't equal or of the wrong type</returns>
public bool EqualTo(int rhs)
{
bool ret = NDalicPINVOKE.Property_Key_EqualTo__SWIG_1(swigCPtr, rhs);
return ret;
}
+ /// <summary>
+ /// Compare if rhs is equal to
+ /// </summary>
+ /// <param name="rhs">A key to compare against</param>
+ /// <returns>Returns true if the keys are of the same type and have the same value</returns>
public bool EqualTo(PropertyKey rhs)
{
bool ret = NDalicPINVOKE.Property_Key_EqualTo__SWIG_2(swigCPtr, PropertyKey.getCPtr(rhs));
return ret;
}
+ /// <summary>
+ /// Compare if rhs is not equal to
+ /// </summary>
+ /// <param name="rhs">An index key to compare against.</param>
+ /// <returns>Returns true if the key is not equal or not a string key</returns>
public bool NotEqualTo(string rhs)
{
bool ret = NDalicPINVOKE.Property_Key_NotEqualTo__SWIG_0(swigCPtr, rhs);
return ret;
}
+ /// <summary>
+ /// Compare if rhs is not equal to
+ /// </summary>
+ /// <param name="rhs">An index key to compare against.</param>
+ /// <returns>Returns true if the key is not equal, or not an index key</returns>
public bool NotEqualTo(int rhs)
{
bool ret = NDalicPINVOKE.Property_Key_NotEqualTo__SWIG_1(swigCPtr, rhs);
return ret;
}
+ /// <summary>
+ /// Compare if rhs is not equal to
+ /// </summary>
+ /// <param name="rhs">A key to compare against.</param>
+ /// <returns>Returns true if the keys are not of the same type or are not equal</returns>
public bool NotEqualTo(PropertyKey rhs)
{
bool ret = NDalicPINVOKE.Property_Key_NotEqualTo__SWIG_2(swigCPtr, PropertyKey.getCPtr(rhs));
return ret;
}
+ /// <summary>
+ /// The type of key
+ /// </summary>
public enum Type
{
Index,
}
+ /// <summary>
+ /// A Map of property values, the key type could be String or Property::Index.
+ /// </summary>
public class PropertyMap : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
+ /// <summary>
+ /// Operator to access the element with the specified string key.
+ /// If an element with the key does not exist, then it is created.
+ /// </summary>
+ /// <param name="key">The key whose value to access</param>
+ /// <returns>A value for the element with the specified key</returns>
public PropertyValue this[string key]
{
get
}
}
+ /// <summary>
+ /// Operator to access the element with the specified index key.
+ /// If an element with the key does not exist, then it is created.
+ /// </summary>
+ /// <param name="key">The key whose value to access</param>
+ /// <returns>A value for the element with the specified key</returns>
public PropertyValue this[int key]
{
get
}
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
public PropertyMap() : this(NDalicPINVOKE.new_Property_Map__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Copy Constructor
+ /// </summary>
+ /// <param name="other">The Map to copy from</param>
public PropertyMap(PropertyMap other) : this(NDalicPINVOKE.new_Property_Map__SWIG_1(PropertyMap.getCPtr(other)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves the number of elements in the map.
+ /// </summary>
+ /// <returns>The number of elements in the map</returns>
public uint Count()
{
uint ret = NDalicPINVOKE.Property_Map_Count(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns whether the map is empty.
+ /// </summary>
+ /// <returns>Returns true if empty, false otherwise</returns>
public bool Empty()
{
bool ret = NDalicPINVOKE.Property_Map_Empty(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Inserts the key-value pair in the Map, with the key type as string.
+ /// Does not check for duplicates.
+ /// </summary>
+ /// <param name="key">The key to insert</param>
+ /// <param name="value">The value to insert</param>
public void Insert(string key, PropertyValue value)
{
NDalicPINVOKE.Property_Map_Insert__SWIG_0(swigCPtr, key, PropertyValue.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Inserts the key-value pair in the Map, with the key type as index.
+ /// Does not check for duplicates.
+ /// </summary>
+ /// <param name="key">The key to insert</param>
+ /// <param name="value">The value to insert</param>
public void Insert(int key, PropertyValue value)
{
NDalicPINVOKE.Property_Map_Insert__SWIG_2(swigCPtr, key, PropertyValue.getCPtr(value));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Inserts the key-value pair in the Map, with the key type as string.
+ /// Does not check for duplicates.
+ /// </summary>
+ /// <param name="key">The key to insert</param>
+ /// <param name="value">The value to insert</param>
+ /// <returns>Returns a reference to this object</returns>
public PropertyMap Add(string key, PropertyValue value)
{
PropertyMap ret = new PropertyMap(NDalicPINVOKE.Property_Map_Add__SWIG_0(swigCPtr, key, PropertyValue.getCPtr(value)), false);
return ret;
}
+ /// <summary>
+ /// Inserts the key-value pair in the Map, with the key type as string.
+ /// Does not check for duplicates.
+ /// </summary>
+ /// <param name="key">The key to insert</param>
+ /// <param name="value">The value to insert</param>
+ /// <returns>Returns a reference to this object</returns>
public PropertyMap Add(int key, PropertyValue value)
{
PropertyMap ret = new PropertyMap(NDalicPINVOKE.Property_Map_Add__SWIG_2(swigCPtr, key, PropertyValue.getCPtr(value)), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the value at the specified position.
+ /// </summary>
+ /// <param name="position">The specified position</param>
+ /// <returns>A reference to the value at the specified position</returns>
public PropertyValue GetValue(uint position)
{
PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_GetValue(swigCPtr, position), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the key at the specified position.
+ /// </summary>
+ /// <param name="position">The specified position</param>
+ /// <returns>A reference to the key at the specified position</returns>
public string GetKey(uint position)
{
string ret = NDalicPINVOKE.Property_Map_GetKey(swigCPtr, position);
return ret;
}
+ /// <summary>
+ /// Retrieve the key at the specified position.
+ /// </summary>
+ /// <param name="position">The specified position</param>
+ /// <returns>A copy of the key at the specified position</returns>
public PropertyKey GetKeyAt(uint position)
{
PropertyKey ret = new PropertyKey(NDalicPINVOKE.Property_Map_GetKeyAt(swigCPtr, position), true);
return ret;
}
+ /// <summary>
+ /// Finds the value for the specified key if it exists.
+ /// </summary>
+ /// <param name="key">The key to find</param>
+ /// <returns>The value if it exists, an empty object otherwise</returns>
public PropertyValue Find(string key)
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_0(swigCPtr, key);
return ret;
}
+ /// <summary>
+ /// Finds the value for the specified key if it exists.
+ /// </summary>
+ /// <param name="key">The key to find</param>
+ /// <returns>The value if it exists, an empty object otherwise</returns>
public PropertyValue Find(int key)
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_2(swigCPtr, key);
return ret;
}
+ /// <summary>
+ /// Finds the value for the specified keys if either exist.
+ /// </summary>
+ /// <param name="indexKey">The index key to find</param>
+ /// <param name="stringKey">The string key to find</param>
+ /// <returns>The value if it exists, an empty object otherwise</returns>
public PropertyValue Find(int indexKey, string stringKey)
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_3(swigCPtr, indexKey, stringKey);
return ret;
}
+ /// <summary>
+ /// Finds the value for the specified key if it exists and its type is type.
+ /// </summary>
+ /// <param name="key">The key to find</param>
+ /// <param name="type">The type to check</param>
+ /// <returns>The value if it exists, an empty value otherwise</returns>
public PropertyValue Find(string key, PropertyType type)
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_4(swigCPtr, key, (int)type);
return ret;
}
+ /// <summary>
+ /// Finds the value for the specified key if it exists and its type is type.
+ /// </summary>
+ /// <param name="key">The key to find</param>
+ /// <param name="type">The type to check</param>
+ /// <returns>The value if it exists, an empty value otherwise</returns>
public PropertyValue Find(int key, PropertyType type)
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Map_Find__SWIG_5(swigCPtr, key, (int)type);
return ret;
}
+ /// <summary>
+ /// Clears the map.
+ /// </summary>
public void Clear()
{
NDalicPINVOKE.Property_Map_Clear(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Merges values from the map 'from' to the current.
+ /// Any values in 'from' will overwrite the values in the current map.
+ /// </summary>
+ /// <param name="from">The map to merge from</param>
public void Merge(PropertyMap from)
{
NDalicPINVOKE.Property_Map_Merge(swigCPtr, PropertyMap.getCPtr(from));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves the element with the specified string key.
+ /// </summary>
+ /// <param name="key">The key whose value to retrieve</param>
+ /// <returns>The value for the element with the specified key</returns>
public PropertyValue ValueOfIndex(string key)
{
PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_ValueOfIndex__SWIG_0(swigCPtr, key), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the element with the specified index key.
+ /// </summary>
+ /// <param name="key">The key whose value to retrieve</param>
+ /// <returns>The value for the element with the specified key</returns>
public PropertyValue ValueOfIndex(int key)
{
PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Map_ValueOfIndex__SWIG_2(swigCPtr, key), false);
return ret;
}
- public PropertyMap Assign(PropertyMap other)
+ /// <summary>
+ /// Copy the map.
+ /// </summary>
+ /// <param name="other">The map to copy from</param>
+ /// <returns>The copied map</returns>
+ internal PropertyMap Assign(PropertyMap other)
{
PropertyMap ret = new PropertyMap(NDalicPINVOKE.Property_Map_Assign(swigCPtr, PropertyMap.getCPtr(other)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// A value-type representing a property value.
+ /// </summary>
public class PropertyValue : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
- // Extension to property value class that allows us to create a
- // PropertyValue from a C# object, e.g. int, float, string
+ /// <summary>
+ /// Extension to property value class that allows us to create a
+ /// PropertyValue from a C# object, e.g. int, float, string
+ /// </summary>
+ /// <param name="obj">An object to create</param>
+ /// <returns>The created value</returns>
static public PropertyValue CreateFromObject(System.Object obj)
{
System.Type type = obj.GetType();
}
+ /// <summary>
+ /// Creates a Size2D property value.
+ /// </summary>
+ /// <param name="vectorValue">A Size2D values</param>
public PropertyValue(Size2D vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Size2D.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Size property value.
+ /// </summary>
+ /// <param name="vectorValue">A Size values</param>
public PropertyValue(Size vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Size.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Position2D property value.
+ /// </summary>
+ /// <param name="vectorValue">A Position2D values</param>
public PropertyValue(Position2D vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Position2D.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Position property value.
+ /// </summary>
+ /// <param name="vectorValue">A Position values</param>
public PropertyValue(Position vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Position.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Color property value.
+ /// </summary>
+ /// <param name="vectorValue">A Color values</param>
public PropertyValue(Color vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_6(Color.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves a Size2D value.
+ /// </summary>
+ /// <param name="vectorValue"> On return, a Size2D value</param>
public bool Get(Size2D vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Size2D.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a Size2D value.
+ /// </summary>
+ /// <param name="vectorValue"> On return, a Size2D value</param>
public bool Get(Size vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Size.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a Position2D value.
+ /// </summary>
+ /// <param name="vectorValue"> On return, a Position2D value</param>
public bool Get(Position2D vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Position2D.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a Position value.
+ /// </summary>
+ /// <param name="vectorValue"> On return, a Position value</param>
public bool Get(Position vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Position.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a Color value.
+ /// </summary>
+ /// <param name="vectorValue"> On return, a Color value</param>
public bool Get(Color vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_7(swigCPtr, Color.getCPtr(vectorValue));
+ /// <summary>
+ /// Default constructor.
+ /// </summary>
public PropertyValue() : this(NDalicPINVOKE.new_Property_Value__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a boolean property value.
+ /// </summary>
+ /// <param name="boolValue">A boolean value</param>
public PropertyValue(bool boolValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_1(boolValue), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates an integer property value.
+ /// </summary>
+ /// <param name="integerValue">An integer value</param>
public PropertyValue(int integerValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_2(integerValue), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a float property value.
+ /// </summary>
+ /// <param name="floatValue">A floating-point value</param>
public PropertyValue(float floatValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_3(floatValue), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Vector2 property value.
+ /// </summary>
+ /// <param name="vectorValue">A vector of 2 floating-point values</param>
public PropertyValue(Vector2 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_4(Vector2.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Vector3 property value.
+ /// </summary>
+ /// <param name="vectorValue">A vector of 3 floating-point values</param>
public PropertyValue(Vector3 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_5(Vector3.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Vector4 property value.
+ /// </summary>
+ /// <param name="vectorValue">A vector of 4 floating-point values</param>
public PropertyValue(Vector4 vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_6(Vector4.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Rectangle property value.
+ /// </summary>
+ /// <param name="vectorValue">A Rectangle values</param>
public PropertyValue(Rectangle vectorValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_9(Rectangle.getCPtr(vectorValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a Rotation property value.
+ /// </summary>
+ /// <param name="quaternion">A Rotation values</param>
public PropertyValue(Rotation quaternion) : this(NDalicPINVOKE.new_Property_Value__SWIG_11(Rotation.getCPtr(quaternion)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a string property value.
+ /// </summary>
+ /// <param name="stringValue">A string</param>
public PropertyValue(string stringValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_12(stringValue), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates an array property value.
+ /// </summary>
+ /// <param name="arrayValue">An array</param>
public PropertyValue(PropertyArray arrayValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_14(PropertyArray.getCPtr(arrayValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a map property value.
+ /// </summary>
+ /// <param name="mapValue">An array</param>
public PropertyValue(PropertyMap mapValue) : this(NDalicPINVOKE.new_Property_Value__SWIG_15(PropertyMap.getCPtr(mapValue)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a PropertyType value.
+ /// </summary>
+ /// <param name="type">A PropertyType values</param>
public PropertyValue(PropertyType type) : this(NDalicPINVOKE.new_Property_Value__SWIG_16((int)type), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Creates a PropertyValue value.
+ /// </summary>
+ /// <param name="value">A PropertyValue values</param>
public PropertyValue(PropertyValue value) : this(NDalicPINVOKE.new_Property_Value__SWIG_17(PropertyValue.getCPtr(value)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
- public PropertyValue Assign(PropertyValue value)
+ /// <summary>
+ /// Copy the value.
+ /// </summary>
+ /// <param name="value">The value to copy from</param>
+ /// <returns>The copied value</returns>
+ internal PropertyValue Assign(PropertyValue value)
{
PropertyValue ret = new PropertyValue(NDalicPINVOKE.Property_Value_Assign(swigCPtr, PropertyValue.getCPtr(value)), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Queries the type of this property value.
+ /// </summary>
+ /// <returns>The type ID</returns>
public PropertyType GetType()
{
PropertyType ret = (PropertyType)NDalicPINVOKE.Property_Value_GetType(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Retrieves a boolean value.
+ /// </summary>
+ /// <param name="boolValue">On return, a boolean value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(ref bool boolValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_1(swigCPtr, ref boolValue);
return ret;
}
+ /// <summary>
+ /// Retrieves a floating-point value.
+ /// </summary>
+ /// <param name="floatValue">On return, a floating-point value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(ref float floatValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_2(swigCPtr, ref floatValue);
return ret;
}
+ /// <summary>
+ /// Retrieves a integer value.
+ /// </summary>
+ /// <param name="integerValue">On return, a integer value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(ref int integerValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_3(swigCPtr, ref integerValue);
return ret;
}
+ /// <summary>
+ /// Retrieves an integer rectangle.
+ /// </summary>
+ /// <param name="rect">On return, an integer rectangle</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(Rectangle rect)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_4(swigCPtr, Rectangle.getCPtr(rect));
return ret;
}
+ /// <summary>
+ /// Retrieves a vector value.
+ /// </summary>
+ /// <param name="vectorValue">On return, a vector value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(Vector2 vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_5(swigCPtr, Vector2.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a vector value.
+ /// </summary>
+ /// <param name="vectorValue">On return, a vector value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(Vector3 vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_6(swigCPtr, Vector3.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a vector value.
+ /// </summary>
+ /// <param name="vectorValue">On return, a vector value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(Vector4 vectorValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_7(swigCPtr, Vector4.getCPtr(vectorValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a Rotation value.
+ /// </summary>
+ /// <param name="quaternionValue">On return, a Rotation value</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(Rotation quaternionValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_11(swigCPtr, Rotation.getCPtr(quaternionValue));
return ret;
}
+ /// <summary>
+ /// Retrieves a string property value.
+ /// </summary>
+ /// <param name="stringValue">On return, a string</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(out string stringValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_12(swigCPtr, out stringValue);
return ret;
}
+ /// <summary>
+ /// Retrieves an array property value.
+ /// </summary>
+ /// <param name="arrayValue">On return, the array as a vector Property Values</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(PropertyArray arrayValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_13(swigCPtr, PropertyArray.getCPtr(arrayValue));
return ret;
}
+ /// <summary>
+ /// Retrieves an map property value.
+ /// </summary>
+ /// <param name="mapValue">On return, the map as vector of string and Property Value pairs</param>
+ /// <returns>Returns true if the value is successfully retrieved, false if the type is not convertible</returns>
public bool Get(PropertyMap mapValue)
{
bool ret = NDalicPINVOKE.Property_Value_Get__SWIG_14(swigCPtr, PropertyMap.getCPtr(mapValue));
return ret;
}
+ /// <summary>
+ /// Retrieves the Array API of the Property::Value without copying the contents of the map.
+ /// </summary>
+ /// <returns>The Array API of the Property::Value or NULL if not a Property::Array</returns>
public PropertyArray GetArray()
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Value_GetArray(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Retrieves the Map API of the Property::Value without copying the contents of the map.
+ /// </summary>
+ /// <returns>The Map API of the Property::Value or NULL if not a Property::Map</returns>
public PropertyMap GetMap()
{
global::System.IntPtr cPtr = NDalicPINVOKE.Property_Value_GetMap(swigCPtr);
projects / platform / core / csapi / nui.git / commitdiff