Package icyllis.modernui.view

# Interface ViewParent

All Known Implementing Classes:
  `AbsListView`, `AbsoluteLayout`, `AbsSpinner`, `AdapterView`, `CoordinatorLayout`, `DropDownListView`, `ExpandableListView`, `FragmentContainerView`, `FrameLayout`, `GridLayout`, `GridView`, `HorizontalScrollView`, `LinearLayout`, `ListMenuItemView`, `ListView`, `MenuPopupWindow.MenuDropDownListView`, `NestedScrollView`, `RadioGroup`, `RelativeLayout`, `RelativeRadioGroup`, `ScrollView`, `Spinner`, `TableLayout`, `TableRow`, `TestFragment.TestLinearLayout`, `ViewGroup`, `ViewPager`, `ViewRoot`, `WindowGroup`

public interface ViewParent
Defines an object that can work as a parent of a View.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `bringChildToFront(View child)`
  Change the z order of the child, so it's on top of all other children.
  `boolean`
  `canResolveLayoutDirection()`
  Tells if this view parent can resolve the layout direction.
  `boolean`
  `canResolveTextAlignment()`
  Tells if this view parent can resolve the text alignment.
  `boolean`
  `canResolveTextDirection()`
  Tells if this view parent can resolve the text direction.
  `void`
  `childDrawableStateChanged(View child)`
  This method is called on the parent when a child's drawable state has changed.
  `void`
  `childHasTransientStateChanged(View child, boolean hasTransientState)`
  Called when a child view now has or no longer is tracking transient state.
  `void`
  `clearChildFocus(View child)`
  Called when a child of this parent is giving up focus
  `void`
  `createContextMenu(ContextMenu menu)`
  Have the parent populate the specified context menu if it has anything to add (and then recurse on its parent).
  `void`
  `focusableViewAvailable(View v)`
  Tells the parent that a new focusable view has become available.
  `View`
  `focusSearch(View v, int direction)`
  Find the nearest view in the specified direction that wants to take focus
  `boolean`
  `getChildVisibleRect(View child, Rect r, Point offset)`
  Compute the visible part of a rectangular region defined in terms of a child view's coordinates.
  `int`
  `getLayoutDirection()`
  Return this view parent layout direction.
  `int`
  `getNestedScrollAxes()`
  Return the current axes of nested scrolling for this NestedScrollingParent.
  `ViewParent`
  `getParent()`
  Returns the parent of this ViewParent.
  `int`
  `getTextAlignment()`
  Return this view parent text alignment.
  `int`
  `getTextDirection()`
  Return this view parent text direction.
  `boolean`
  `isLayoutDirectionResolved()`
  Tells if this view parent layout direction is resolved.
  `boolean`
  `isLayoutRequested()`
  Indicates whether layout was requested on this view parent.
  `boolean`
  `isTextAlignmentResolved()`
  Tells if this view parent text alignment is resolved.
  `boolean`
  `isTextDirectionResolved()`
  Tells if this view parent text direction is resolved.
  `View`
  `keyboardNavigationClusterSearch(View currentCluster, int direction)`
  Find the nearest keyboard navigation cluster in the specified direction.
  `boolean`
  `onNestedFling(View target, float velocityX, float velocityY, boolean consumed)`
  Request a fling from a nested scroll.
  `boolean`
  `onNestedPreFling(View target, float velocityX, float velocityY)`
  React to a nested fling before the target view consumes it.
  `void`
  `onNestedPreScroll(View target, int dx, int dy, int[] consumed, int type)`
  React to a nested scroll in progress before the target view consumes a portion of the scroll.
  `void`
  `onNestedScroll(View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type, int[] consumed)`
  React to a nested scroll in progress.
  `void`
  `onNestedScrollAccepted(View child, View target, int axes, int type)`
  React to the successful claiming of a nested scroll operation.
  `boolean`
  `onStartNestedScroll(View child, View target, int axes, int type)`
  React to a descendant view initiating a nestable scroll operation, claiming the nested scroll operation if appropriate.
  `void`
  `onStopNestedScroll(View target, int type)`
  React to a nested scroll operation ending.
  `void`
  `requestChildFocus(View child, View focused)`
  Called when a child of this parent wants focus
  `boolean`
  `requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate)`
  Called when a child of this group wants a particular rectangle to be positioned onto the screen.
  `void`
  `requestDisallowInterceptTouchEvent(boolean disallowIntercept)`
  Called when a child does not want this parent and its ancestors to intercept touch events with `ViewGroup.onInterceptTouchEvent(MotionEvent)`.
  `void`
  `requestLayout()`
  Called when something has changed which has invalidated the layout of a child of this view parent.
  `boolean`
  `showContextMenuForChild(View originalView, float x, float y)`
  Shows the context menu for the specified view or its ancestors anchored to the specified view-relative coordinate.
  `ActionMode`
  `startActionModeForChild(View originalView, ActionMode.Callback callback, int type)`
  Start an action mode of a specific type for the specified view.

- ## Method Details

  - ### getParent

    @Nullable ViewParent getParent()
    Returns the parent of this ViewParent.
    Returns:
      the parent or `null` if the parent is not available

  - ### requestLayout

    void requestLayout()
    Called when something has changed which has invalidated the layout of a child of this view parent. This will schedule a layout pass of the view tree.

  - ### isLayoutRequested

    boolean isLayoutRequested()
    Indicates whether layout was requested on this view parent.
    Returns:
      true if layout was requested, false otherwise

  - ### requestChildFocus

    void requestChildFocus(View child, View focused)
    Called when a child of this parent wants focus
    Parameters:
      `child` - The child of this ViewParent that wants focus. This view will contain the focused view. It is not necessarily the view that actually has focus.
      `focused` - The view that is a descendant of child that actually has focus

  - ### clearChildFocus

    void clearChildFocus(View child)
    Called when a child of this parent is giving up focus
    Parameters:
      `child` - The view that is giving up focus

  - ### getChildVisibleRect

    boolean getChildVisibleRect(View child, Rect r, @Nullable Point offset)
    Compute the visible part of a rectangular region defined in terms of a child view's coordinates.

    Returns the clipped visible part of the rectangle `r`, defined in the `child`'s local coordinate system. `r` is modified by this method to contain the result, expressed in the global (root) coordinate system.

    The resulting rectangle is always axis aligned. If a rotation is applied to a node in the View hierarchy, the result is the axis-aligned bounding box of the visible rectangle.

    Parameters:
      `child` - A child View, whose rectangular visible region we want to compute
      `r` - The input rectangle, defined in the child coordinate system. Will be overwritten to contain the resulting visible rectangle, expressed in global (root) coordinates
      `offset` - The input coordinates of a point, defined in the child coordinate system. As with the `r` parameter, this will be overwritten to contain the global (root) coordinates of that point. A `null` value is valid (in case you are not interested in this result)
    Returns:
      true if the resulting rectangle is not empty, false otherwise

  - ### focusSearch

    View focusSearch(View v, int direction)
    Find the nearest view in the specified direction that wants to take focus
    Parameters:
      `v` - The view that currently has focus
      `direction` - One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and FOCUS_RIGHT

  - ### keyboardNavigationClusterSearch

    View keyboardNavigationClusterSearch(View currentCluster, int direction)
    Find the nearest keyboard navigation cluster in the specified direction. This does not actually give focus to that cluster.
    Parameters:
      `currentCluster` - The starting point of the search. Null means the current cluster is not found yet
      `direction` - Direction to look
    Returns:
      The nearest keyboard navigation cluster in the specified direction, or null if none can be found

  - ### bringChildToFront

    void bringChildToFront(View child)
    Change the z order of the child, so it's on top of all other children. This ordering change may affect layout, if this container uses an order-dependent layout scheme (e.g., LinearLayout).
    Parameters:
      `child` - The child to bring to the top of the z order

  - ### focusableViewAvailable

    void focusableViewAvailable(View v)
    Tells the parent that a new focusable view has become available. This is to handle transitions from the case where there are no focusable views to the case where the first focusable view appears.
    Parameters:
      `v` - The view that has become newly focusable

  - ### showContextMenuForChild

    boolean showContextMenuForChild(View originalView, float x, float y)
    Shows the context menu for the specified view or its ancestors anchored to the specified view-relative coordinate.

    In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, `ViewManager.addView(View, ViewGroup.LayoutParams)`) then it should override this and show the context menu.

    Parameters:
      `originalView` - the source view where the context menu was first invoked
      `x` - the X coordinate in pixels relative to the original view to which the menu should be anchored, or `Float.NaN` to disable anchoring
      `y` - the Y coordinate in pixels relative to the original view to which the menu should be anchored, or `Float.NaN` to disable anchoring
    Returns:
      `true` if the context menu was shown, `false` otherwise

  - ### createContextMenu

    void createContextMenu(ContextMenu menu)
    Have the parent populate the specified context menu if it has anything to add (and then recurse on its parent).
    Parameters:
      `menu` - The menu to populate

  - ### startActionModeForChild

    ActionMode startActionModeForChild(View originalView, ActionMode.Callback callback, int type)
    Start an action mode of a specific type for the specified view.

    In most cases, a subclass does not need to override this. However, if the subclass is added directly to the window manager (for example, `ViewManager.addView(View, ViewGroup.LayoutParams)`) then it should override this and start the action mode.

    Parameters:
      `originalView` - The source view where the action mode was first invoked
      `callback` - The callback that will handle lifecycle events for the action mode
      `type` - One of `ActionMode.TYPE_PRIMARY` or `ActionMode.TYPE_FLOATING`.
    Returns:
      The new action mode if it was started, null otherwise

  - ### childDrawableStateChanged

    void childDrawableStateChanged(View child)
    This method is called on the parent when a child's drawable state has changed.
    Parameters:
      `child` - The child whose drawable state has changed.

  - ### requestDisallowInterceptTouchEvent

    void requestDisallowInterceptTouchEvent(boolean disallowIntercept)
    Called when a child does not want this parent and its ancestors to intercept touch events with `ViewGroup.onInterceptTouchEvent(MotionEvent)`.

    This parent should pass this call onto its parents. This parent must obey this request for the duration of the touch (that is, only clear the flag after this parent has received an up or a cancel.

    Parameters:
      `disallowIntercept` - True if the child does not want the parent to intercept touch events.

  - ### requestChildRectangleOnScreen

    boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate)
    Called when a child of this group wants a particular rectangle to be positioned onto the screen. `ViewGroup`s overriding this can trust that:
    - child will be a direct child of this group
    - rectangle will be in the child's content coordinates

    `ViewGroup`s overriding this should uphold the contract:

    - nothing will change if the rectangle is already visible
    - the view port will be scrolled only just enough to make the rectangle visible
    Parameters:
      `child` - The direct child making the request.
      `rectangle` - The rectangle in the child's coordinates the child wishes to be on the screen.
      `immediate` - True to forbid animated or delayed scrolling, false otherwise
    Returns:
      Whether the group scrolled to handle the operation

  - ### childHasTransientStateChanged

    void childHasTransientStateChanged(View child, boolean hasTransientState)
    Called when a child view now has or no longer is tracking transient state.

    "Transient state" is any state that a View might hold that is not expected to be reflected in the data model that the View currently presents. This state only affects the presentation to the user within the View itself, such as the current state of animations in progress or the state of a text selection operation.

    Transient state is useful for hinting to other components of the View system that a particular view is tracking something complex but encapsulated. A `ListView` for example may acknowledge that list item Views with transient state should be preserved within their position or stable item ID instead of treating that view as trivially replaceable by the backing adapter. This allows adapter implementations to be simpler instead of needing to track the state of item view animations in progress such that they could be restored in the event of an unexpected recycling and rebinding of attached item views.

    This method is called on a parent view when a child view or a view within its subtree begins or ends tracking of internal transient state.

    Parameters:
      `child` - Child view whose state has changed
      `hasTransientState` - true if this child has transient state

  - ### canResolveLayoutDirection

    boolean canResolveLayoutDirection()
    Tells if this view parent can resolve the layout direction. See `View.setLayoutDirection(int)`
    Returns:
      True if this view parent can resolve the layout direction.

  - ### isLayoutDirectionResolved

    boolean isLayoutDirectionResolved()
    Tells if this view parent layout direction is resolved. See `View.setLayoutDirection(int)`
    Returns:
      True if this view parent layout direction is resolved.

  - ### getLayoutDirection

    int getLayoutDirection()
    Return this view parent layout direction. See `View.getLayoutDirection()`
    Returns:
      `View.LAYOUT_DIRECTION_RTL` if the layout direction is RTL or returns `View.LAYOUT_DIRECTION_LTR` if the layout direction is not RTL.

  - ### canResolveTextDirection

    boolean canResolveTextDirection()
    Tells if this view parent can resolve the text direction. See `View.setTextDirection(int)`
    Returns:
      True if this view parent can resolve the text direction.

  - ### isTextDirectionResolved

    boolean isTextDirectionResolved()
    Tells if this view parent text direction is resolved. See `View.setTextDirection(int)`
    Returns:
      True if this view parent text direction is resolved.

  - ### getTextDirection

    int getTextDirection()
    Return this view parent text direction. See `View.getTextDirection()`
    Returns:
      the resolved text direction. Returns one of:

      `View.TEXT_DIRECTION_FIRST_STRONG` `View.TEXT_DIRECTION_ANY_RTL`, `View.TEXT_DIRECTION_LTR`, `View.TEXT_DIRECTION_RTL`, `View.TEXT_DIRECTION_LOCALE`

  - ### canResolveTextAlignment

    boolean canResolveTextAlignment()
    Tells if this view parent can resolve the text alignment. See `View.setTextAlignment(int)`
    Returns:
      True if this view parent can resolve the text alignment.

  - ### isTextAlignmentResolved

    boolean isTextAlignmentResolved()
    Tells if this view parent text alignment is resolved. See `View.setTextAlignment(int)`
    Returns:
      True if this view parent text alignment is resolved.

  - ### getTextAlignment

    int getTextAlignment()
    Return this view parent text alignment. See `View.getTextAlignment()`
    Returns:
      the resolved text alignment. Returns one of:

      `View.TEXT_ALIGNMENT_GRAVITY`, `View.TEXT_ALIGNMENT_CENTER`, `View.TEXT_ALIGNMENT_TEXT_START`, `View.TEXT_ALIGNMENT_TEXT_END`, `View.TEXT_ALIGNMENT_VIEW_START`, `View.TEXT_ALIGNMENT_VIEW_END`

  - ### onStartNestedScroll

    boolean onStartNestedScroll(@NonNull View child, @NonNull View target, int axes, int type)
    React to a descendant view initiating a nestable scroll operation, claiming the nested scroll operation if appropriate.

    This method will be called in response to a descendant view invoking `View.startNestedScroll(int, int)`. Each parent up the view hierarchy will be given an opportunity to respond and claim the nested scrolling operation by returning `true`.

    This method may be overridden by ViewParent implementations to indicate when the view is willing to support a nested scrolling operation that is about to begin. If it returns true, this ViewParent will become the target view's nested scrolling parent for the duration of the scroll operation in progress. When the nested scroll is finished this ViewParent will receive a call to `onStopNestedScroll(View, int)`.

    Parameters:
      `child` - Direct child of this ViewParent containing target
      `target` - View that initiated the nested scroll
      `axes` - Flags consisting of `View.SCROLL_AXIS_HORIZONTAL`, `View.SCROLL_AXIS_VERTICAL` or both
      `type` - the type of input which cause this scroll event
    Returns:
      true if this ViewParent accepts the nested scroll operation

  - ### onNestedScrollAccepted

    void onNestedScrollAccepted(@NonNull View child, @NonNull View target, int axes, int type)
    React to the successful claiming of a nested scroll operation.

    This method will be called after `onStartNestedScroll` returns true. It offers an opportunity for the view and its superclasses to perform initial configuration for the nested scroll. Implementations of this method should always call their superclasses' implementation of this method if one is present.

    Parameters:
      `child` - Direct child of this ViewParent containing target
      `target` - View that initiated the nested scroll
      `axes` - Flags consisting of `View.SCROLL_AXIS_HORIZONTAL`, `View.SCROLL_AXIS_VERTICAL` or both
      `type` - the type of input which cause this scroll event
    See Also:
      - `onStartNestedScroll(View, View, int, int)`
      - `onStopNestedScroll(View, int)`

  - ### onStopNestedScroll

    void onStopNestedScroll(@NonNull View target, int type)
    React to a nested scroll operation ending.

    Perform cleanup after a nested scrolling operation. This method will be called when a nested scroll stops, for example when a nested touch scroll ends with a `MotionEvent.ACTION_UP` or `MotionEvent.ACTION_CANCEL` event. Implementations of this method should always call their superclasses' implementation of this method if one is present.

    Parameters:
      `target` - View that initiated the nested scroll
      `type` - the type of input which cause this scroll event

  - ### onNestedScroll

    void onNestedScroll(@NonNull View target, int dxConsumed, int dyConsumed, int dxUnconsumed, int dyUnconsumed, int type, @NonNull int[] consumed)
    React to a nested scroll in progress.

    This method will be called when the ViewParent's current nested scrolling child view dispatches a nested scroll event. To receive calls to this method the ViewParent must have previously returned `true` for a call to `onStartNestedScroll(View, View, int, int)`.

    Both the consumed and unconsumed portions of the scroll distance are reported to the ViewParent. An implementation may choose to use the consumed portion to match or chase scroll position of multiple child elements, for example. The unconsumed portion may be used to allow continuous dragging of multiple scrolling or draggable elements, such as scrolling a list within a vertical drawer where the drawer begins dragging once the edge of inner scrolling content is reached.

    This method is called when a nested scrolling child invokes `View.dispatchNestedScroll(int, int, int, int, int[], int, int[])`} or one of methods it overloads.

    An implementation must report how many pixels of the x and y scroll distances were consumed by this nested scrolling parent by adding the consumed distances to the `consumed` parameter. `consumed` should also be passed up to it's nested scrolling parent so that the parent may also add any scroll distance it consumes. Index 0 corresponds to dx and index 1 corresponds to dy.

    Parameters:
      `target` - The descendant view controlling the nested scroll
      `dxConsumed` - Horizontal scroll distance in pixels already consumed by target
      `dyConsumed` - Vertical scroll distance in pixels already consumed by target
      `dxUnconsumed` - Horizontal scroll distance in pixels not consumed by target
      `dyUnconsumed` - Vertical scroll distance in pixels not consumed by target
      `type` - the type of input which cause this scroll event
      `consumed` - Output. Upon this method returning, will contain the scroll distances consumed by this nested scrolling parent and the scroll distances consumed by any other parent up the view hierarchy
    See Also:
      - `View.dispatchNestedScroll(int, int, int, int, int[], int, int[])`

  - ### onNestedPreScroll

    void onNestedPreScroll(@NonNull View target, int dx, int dy, @NonNull int[] consumed, int type)
    React to a nested scroll in progress before the target view consumes a portion of the scroll.

    When working with nested scrolling often the parent view may want an opportunity to consume the scroll before the nested scrolling child does. An example of this is a drawer that contains a scrollable list. The user will want to be able to scroll the list fully into view before the list itself begins scrolling.

    `onNestedPreScroll` is called when a nested scrolling child invokes `View.dispatchNestedPreScroll(int, int, int[], int[], int)`. The implementation should report how any pixels of the scroll reported by dx, dy were consumed in the `consumed` array. Index 0 corresponds to dx and index 1 corresponds to dy. This parameter will never be null. Initial values for consumed[0] and consumed[1] will always be 0.

    Parameters:
      `target` - View that initiated the nested scroll
      `dx` - Horizontal scroll distance in pixels
      `dy` - Vertical scroll distance in pixels
      `consumed` - Output. The horizontal and vertical scroll distance consumed by this parent
      `type` - the type of input which cause this scroll event

  - ### onNestedFling

    boolean onNestedFling(@NonNull View target, float velocityX, float velocityY, boolean consumed)
    Request a fling from a nested scroll.

    This method signifies that a nested scrolling child has detected suitable conditions for a fling. Generally this means that a touch scroll has ended with a `velocity` in the direction of scrolling that meets or exceeds the `minimum fling velocity` along a scrollable axis.

    If a nested scrolling child view would normally fling but it is at the edge of its own content, it can use this method to delegate the fling to its nested scrolling parent instead. The parent may optionally consume the fling or observe a child fling.

    Parameters:
      `target` - View that initiated the nested scroll
      `velocityX` - Horizontal velocity in pixels per second
      `velocityY` - Vertical velocity in pixels per second
      `consumed` - true if the child consumed the fling, false otherwise
    Returns:
      true if this parent consumed or otherwise reacted to the fling

  - ### onNestedPreFling

    boolean onNestedPreFling(@NonNull View target, float velocityX, float velocityY)
    React to a nested fling before the target view consumes it.

    This method signifies that a nested scrolling child has detected a fling with the given velocity along each axis. Generally this means that a touch scroll has ended with a `velocity` in the direction of scrolling that meets or exceeds the `minimum fling velocity` along a scrollable axis.

    If a nested scrolling parent is consuming motion as part of a `pre-scroll`, it may be appropriate for it to also consume the pre-fling to complete that same motion. By returning `true` from this method, the parent indicates that the child should not fling its own internal content as well.

    Parameters:
      `target` - View that initiated the nested scroll
      `velocityX` - Horizontal velocity in pixels per second
      `velocityY` - Vertical velocity in pixels per second
    Returns:
      true if this parent consumed the fling ahead of the target view

  - ### getNestedScrollAxes

    int getNestedScrollAxes()
    Return the current axes of nested scrolling for this NestedScrollingParent.

    A NestedScrollingParent returning something other than `View.SCROLL_AXIS_NONE` is currently acting as a nested scrolling parent for one or more descendant views in the hierarchy.

    Returns:
      Flags indicating the current axes of nested scrolling
    See Also:
      - `View.SCROLL_AXIS_HORIZONTAL`
      - `View.SCROLL_AXIS_VERTICAL`
      - `View.SCROLL_AXIS_NONE`