/// Sets the background with a property map.
/// </summary>
/// <param name="map">The background property map.</param>
+ /// <since_tizen> 3 </since_tizen>
public void SetBackground(Tizen.NUI.PropertyMap map)
{
viewWrapperImpl.SetBackground(map);
/// Gesture detection can be enabled one at a time or in a bitwise format.<br>
/// </summary>
/// <param name="type">The gesture type(s) to enable.</param>
+ /// <since_tizen> 3 </since_tizen>
public void EnableGestureDetection(Gesture.GestureType type)
{
viewWrapperImpl.EnableGestureDetection(type);
/// The control doesn't support it by default.<br>
/// </summary>
/// <param name="isSupported">Whether this control supports two dimensional keyboard navigation.</param>
+ /// <since_tizen> 3 </since_tizen>
public bool FocusNavigationSupport
{
get
/// Sets or gets whether this control is a focus group for keyboard navigation.
/// </summary>
/// <returns>True if this control is set as a focus group for keyboard navigation.</returns>
+ /// <since_tizen> 3 </since_tizen>
public bool FocusGroup
{
get
/// This method is called after the control has been initialized.<br>
/// Derived classes should do any second phase initialization by overriding this method.<br>
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnInitialize()
{
}
/// When the parent of a set of views is connected to the stage, then all of the children will receive this callback.<br>
/// </summary>
/// <param name="depth">The depth in the hierarchy for the view.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnStageConnection(int depth)
{
}
/// If a view is disconnected, it either has no parent, or is parented to a disconnected view.<br>
/// When the parent of a set of views is disconnected to the stage, then all of the children will receive this callback, starting with the leaf views.<br>
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnStageDisconnection()
{
}
/// Called after a child has been added to the owning view.
/// </summary>
/// <param name="view">The child which has been added.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnChildAdd(View view)
{
}
/// Called after the owning view has attempted to remove a child( regardless of whether it succeeded or not ).
/// </summary>
/// <param name="view">The child being removed.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnChildRemove(View view)
{
}
/// </summary>
/// <param name="index">The property index that was set.</param>
/// <param name="propertyValue">The value to set.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnPropertySet(int index, Tizen.NUI.PropertyValue propertyValue)
{
}
/// Called when the owning view's size is set, for example, using View.SetSize().
/// </summary>
/// <param name="targetSize">The target size.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnSizeSet(Vector3 targetSize)
{
}
/// </summary>
/// <param name="animation">The object which is animating the owning view.</param>
/// <param name="targetSize">The target size.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnSizeAnimation(Animation animation, Vector3 targetSize)
{
}
/// </summary>
/// <param name="touch">The touch event.</param>
/// <returns>True if the event should be consumed.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool OnTouch(Touch touch)
{
return false; // Do not consume
/// </summary>
/// <param name="hover">The hover event.</param>
/// <returns>True if the hover event should be consumed.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool OnHover(Hover hover)
{
return false; // Do not consume
/// </summary>
/// <param name="key">The key event.</param>
/// <returns>True if the key event should be consumed.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool OnKey(Key key)
{
return false; // Do not consume
/// </summary>
/// <param name="wheel">The wheel event.</param>
/// <returns>True if the wheel event should be consumed.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool OnWheel(Wheel wheel)
{
return false; // Do not consume
/// </summary>
/// <param name="size">The allocated size.</param>
/// <param name="container">The control should add views to this container that it is not able to allocate a size for.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnRelayout(Vector2 size, RelayoutContainer container)
{
}
/// </summary>
/// <param name="policy">The policy being set.</param>
/// <param name="dimension">The policy is being set for.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnSetResizePolicy(ResizePolicyType policy, DimensionType dimension)
{
}
/// Returns the natural size of the view.
/// </summary>
/// <returns>The view's natural size</returns>
+ /// <since_tizen> 3 </since_tizen>
public new virtual Size2D GetNaturalSize()
{
return new Size2D(0, 0);
/// <param name="child">The child view to calculate the size for.</param>
/// <param name="dimension">The dimension to calculate the size, for example, the width or the height.</param>
/// <returns>Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual float CalculateChildSize(View child, DimensionType dimension)
{
return viewWrapperImpl.CalculateChildSizeBase(child, dimension);
/// </summary>
/// <param name="width">Width to use</param>
/// <returns>The height based on the width</returns>
+ /// <since_tizen> 3 </since_tizen>
public new virtual float GetHeightForWidth(float width)
{
return viewWrapperImpl.GetHeightForWidthBase(width);
/// </summary>
/// <param name="height">Height to use</param>
/// <returns>The width based on the width</returns>
+ /// <since_tizen> 3 </since_tizen>
public new virtual float GetWidthForHeight(float height)
{
return viewWrapperImpl.GetWidthForHeightBase(height);
/// </summary>
/// <param name="dimension">The dimension(s) to check for.</param>
/// <returns>Return if the view is dependent on it's children.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool RelayoutDependentOnChildren(DimensionType dimension)
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase(dimension);
/// Determines if this view is dependent on it's children for relayout from the base class.
/// </summary>
/// <returns>Return true if the view is dependent on it's children.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool RelayoutDependentOnChildren()
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase();
/// met and the size for this object is about to be calculated for the given dimension.
/// </summary>
/// <param name="dimension">The dimension that is about to be calculated.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnCalculateRelayoutSize(DimensionType dimension)
{
}
/// </summary>
/// <param name="size">The new size for the given dimension.</param>
/// <param name="dimension">The dimension that was just negotiated.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnLayoutNegotiated(float size, DimensionType dimension)
{
}
/// </summary>
/// <param name="styleManager">The StyleManager object.</param>
/// <param name="change">Information denoting what has changed.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnStyleChange(StyleManager styleManager, StyleChangeType change)
{
}
/// <summary>
/// Called when the control gain key input focus. Should be overridden by derived classes if they need to customize what happens when the focus is gained.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnFocusGained()
{
}
/// <summary>
/// Called when the control loses key input focus. Should be overridden by derived classes if they need to customize what happens when the focus is lost.
/// </summary>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnFocusLost()
{
}
/// <param name="direction">The direction to move the focus towards.</param>
/// <param name="loopEnabled">Whether the focus movement should be looped within the control.</param>
/// <returns>The next keyboard focusable view in this control or an empty handle if no view can be focused.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled)
{
return new View();
/// This allows the application to preform any actions it wishes before the focus is actually moved to the chosen view.<br>
/// </summary>
/// <param name="commitedFocusableView">The commited focused view.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnFocusChangeCommitted(View commitedFocusableView)
{
}
/// Derived classes should override this to perform custom actions.<br>
/// </summary>
/// <returns>True if this control supported this action.</returns>
+ /// <since_tizen> 3 </since_tizen>
public virtual bool OnKeyboardEnter()
{
return false;
/// Pan detection should be enabled via EnableGestureDetection().<br>
/// </summary>
/// <param name="pan">The pan gesture.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnPan(PanGesture pan)
{
}
/// Tap detection should be enabled via EnableGestureDetection().<br>
/// </summary>
/// <param name="tap">The tap gesture.</param>
+ /// <since_tizen> 3 </since_tizen>
public virtual void OnTap(TapGesture tap)
{
}
{
}
}
-}
+}
\ No newline at end of file
projects / platform / core / csapi / tizenfx.git / blobdiff