HorizontalGridView

Kotlin |Java

open class HorizontalGridView : BaseGridView

kotlin.Any
↳	android.view.View
	↳	android.view.ViewGroup
		↳	androidx.recyclerview.widget.RecyclerView
			↳	androidx.leanback.widget.BaseGridView
				↳	androidx.leanback.widget.HorizontalGridView

A android.view.ViewGroup that shows items in a horizontal scrolling list. The items come from the RecyclerView.Adapter associated with this view.

RecyclerView.Adapter can optionally implement FacetProviderAdapter which provides FacetProvider for a given view type; RecyclerView.ViewHolder can also implement FacetProvider. Facet from ViewHolder has a higher priority than the one from FacetProviderAdapter associated with viewType. Supported optional facets are:

ItemAlignmentFacet When this facet is provided by ViewHolder or FacetProviderAdapter, it will override the item alignment settings set on HorizontalGridView. This facet also allows multiple alignment positions within one ViewHolder.

Summary

Inherited constants

From class RecyclerView

`Int`	`HORIZONTAL`
`Int`	`INVALID_TYPE`
`Long`	`NO_ID`
`Int`	`NO_POSITION`
`Int`	`SCROLL_STATE_DRAGGING` The RecyclerView is currently being dragged by outside input such as user touch input.
`Int`	`SCROLL_STATE_IDLE` The RecyclerView is not currently scrolling.
`Int`	`SCROLL_STATE_SETTLING` The RecyclerView is currently animating to a final position while not under outside control.
`Int`	`TOUCH_SLOP_DEFAULT` Constant for use with `setScrollingTouchSlop(int)`. Indicates that the RecyclerView should use the standard touch slop for smooth, continuous scrolling.
`Int`	`TOUCH_SLOP_PAGING` Constant for use with `setScrollingTouchSlop(int)`. Indicates that the RecyclerView should use the standard touch slop for scrolling widgets that snap to a page or other coarse-grained barrier.
`Int`	`UNDEFINED_DURATION` Constant that represents that a duration has not been defined.
`Int`	`VERTICAL`

From class BaseGridView

`Float`	`ITEM_ALIGN_OFFSET_PERCENT_DISABLED` Value indicates that percent is not used.
`Int`	`SAVE_ALL_CHILD` Save on screen views plus save off screen child views without any limitation. This might cause out of memory, only use it when you are dealing with limited data.
`Int`	`SAVE_LIMITED_CHILD` Save on screen views plus save off screen child views states up to `getSaveChildrenLimitNumber()`.
`Int`	`SAVE_NO_CHILD` Dont save states of any child views.
`Int`	`SAVE_ON_SCREEN_CHILD` Only save on screen child views, the states are lost when they become off screen.
`Int`	`WINDOW_ALIGN_BOTH_EDGE` The first item and last item are aligned with the two edges of the viewport. When navigating in the middle of list, the focus maintains a key line location. The key line location is calculated by "windowAlignOffset" and "windowAlignOffsetPercent"; if neither of these two is defined, the default value is 1/2 of the size.
`Int`	`WINDOW_ALIGN_HIGH_EDGE` The last item is aligned with the high edge of the viewport when navigating to the end of list. When navigating away from the end, the focus item is aligned to a key line location. For HorizontalGridView, high edge refers to getWidth() - getPaddingRight() when RTL is false or getPaddingLeft() when RTL is true. For VerticalGridView, high edge refers to getHeight() - getPaddingBottom(). The key line location is calculated by "windowAlignOffset" and "windowAlignOffsetPercent"; if neither of these two is defined, the default value is 1/2 of the size. Note if there are very few items between high edge and key line, use `setWindowAlignmentPreferKeyLineOverHighEdge(boolean)` to control whether you prefer to align the items to key line or high edge. Default is preferring key line.
`Int`	`WINDOW_ALIGN_LOW_EDGE` The first item is aligned with the low edge of the viewport. When navigating away from the first item, the focus item is aligned to a key line location. For HorizontalGridView, low edge refers to getPaddingLeft() when RTL is false or getWidth() - getPaddingRight() when RTL is true. For VerticalGridView, low edge refers to getPaddingTop(). The key line location is calculated by "windowAlignOffset" and "windowAlignOffsetPercent"; if neither of these two is defined, the default value is 1/2 of the size. Note if there are very few items between low edge and key line, use `setWindowAlignmentPreferKeyLineOverLowEdge(boolean)` to control whether you prefer to align the items to key line or low edge. Default is preferring low edge.
`Int`	`WINDOW_ALIGN_NO_EDGE` The focused item always stays in a key line location. The key line location is calculated by "windowAlignOffset" and "windowAlignOffsetPercent"; if neither of these two is defined, the default value is 1/2 of the size.
`Float`	`WINDOW_ALIGN_OFFSET_PERCENT_DISABLED` Value indicates that percent is not used.

Public constructors
`<init>(context: Context!)`
`<init>(context: Context!, attrs: AttributeSet!)`
`<init>(context: Context!, attrs: AttributeSet!, defStyle: Int)`

Public methods
open Unit	`draw(canvas: Canvas!)`
Boolean	`getFadingLeftEdge()` Returns true if left edge fading is enabled.
Int	`getFadingLeftEdgeLength()` Returns the left edge fading length in pixels.
Int	`getFadingLeftEdgeOffset()` Returns the distance in pixels between fading start position and left padding edge.
Boolean	`getFadingRightEdge()` Returns true if fading right edge is enabled.
Int	`getFadingRightEdgeLength()` Returns the right edge fading length in pixels.
Int	`getFadingRightEdgeOffset()` Sets the distance in pixels between fading start position and right padding edge.
Unit	`setFadingLeftEdge(fading: Boolean)` Sets the fade out left edge to transparent.
Unit	`setFadingLeftEdgeLength(fadeLength: Int)` Sets the left edge fading length in pixels.
Unit	`setFadingLeftEdgeOffset(fadeOffset: Int)` Sets the distance in pixels between fading start position and left padding edge.
Unit	`setFadingRightEdge(fading: Boolean)` Sets the fade out right edge to transparent.
Unit	`setFadingRightEdgeLength(fadeLength: Int)` Sets the right edge fading length in pixels.
Unit	`setFadingRightEdgeOffset(fadeOffset: Int)` Returns the distance in pixels between fading start position and right padding edge.
open Unit	`setNumRows(numRows: Int)` Sets the number of rows.
open Unit	`setRowHeight(height: Int)` Sets the row height.

Protected methods
open Unit	`initAttributes(context: Context!, attrs: AttributeSet!)`

Inherited functions

From class RecyclerView

`Unit`	`addFocusables(views: ArrayList<View!>!, direction: Int, focusableMode: Int)`
`Unit`	`addItemDecoration(@NonNull decor: RecyclerView.ItemDecoration, index: Int)` Add an `ItemDecoration` to this RecyclerView. Item decorations can affect both measurement and drawing of individual item views. Item decorations are ordered. Decorations placed earlier in the list will be run/queried/drawn first for their effects on item views. Padding added to views will be nested; a padding added by an earlier decoration will mean further item decorations in the list will be asked to draw/pad within the previous decoration's given area.
`Unit`	`addItemDecoration(@NonNull decor: RecyclerView.ItemDecoration)` Add an `ItemDecoration` to this RecyclerView. Item decorations can affect both measurement and drawing of individual item views. Item decorations are ordered. Decorations placed earlier in the list will be run/queried/drawn first for their effects on item views. Padding added to views will be nested; a padding added by an earlier decoration will mean further item decorations in the list will be asked to draw/pad within the previous decoration's given area.
`Unit`	`addOnChildAttachStateChangeListener(@NonNull listener: RecyclerView.OnChildAttachStateChangeListener)` Register a listener that will be notified whenever a child view is attached to or detached from RecyclerView. This listener will be called when a LayoutManager or the RecyclerView decides that a child view is no longer needed. If an application associates expensive or heavyweight data with item views, this may be a good place to release or free those resources.
`Unit`	`addOnItemTouchListener(@NonNull listener: RecyclerView.OnItemTouchListener)` Add an `OnItemTouchListener` to intercept touch events before they are dispatched to child views or this view's standard scrolling behavior. Client code may use listeners to implement item manipulation behavior. Once a listener returns true from `OnItemTouchListener#onInterceptTouchEvent(RecyclerView, MotionEvent)` its `OnItemTouchListener#onTouchEvent(RecyclerView, MotionEvent)` method will be called for each incoming MotionEvent until the end of the gesture.
`Unit`	`addOnScrollListener(@NonNull listener: RecyclerView.OnScrollListener)` Add a listener that will be notified of any changes in scroll state or position. Components that add a listener should take care to remove it when finished. Other components that take ownership of a view may call `clearOnScrollListeners()` to remove all attached listeners.
`Unit`	`addRecyclerListener(@NonNull listener: RecyclerView.RecyclerListener)` Register a listener that will be notified whenever a child view is recycled. The listeners will be called when a LayoutManager or the RecyclerView decides that a child view is no longer needed. If an application associates data with the item views being recycled, this may be a good place to release or free those resources.
`Boolean`	`checkLayoutParams(p: LayoutParams!)`
`Unit`	`clearOnChildAttachStateChangeListeners()` Removes all listeners that were added via `addOnChildAttachStateChangeListener(OnChildAttachStateChangeListener)`.
`Unit`	`clearOnScrollListeners()` Remove all secondary listener that were notified of any changes in scroll state or position.
`Int`	`computeHorizontalScrollExtent()` Compute the horizontal extent of the horizontal scrollbar's thumb within the horizontal range. This value is used to compute the length of the thumb within the scrollbar's track. The range is expressed in arbitrary units that must be the same as the units used by `computeHorizontalScrollRange()` and `computeHorizontalScrollOffset()`. Default implementation returns 0. If you want to support scroll bars, override `RecyclerView.LayoutManager#computeHorizontalScrollExtent(RecyclerView.State)` in your LayoutManager.
`Int`	`computeHorizontalScrollOffset()` Compute the horizontal offset of the horizontal scrollbar's thumb within the horizontal range. This value is used to compute the length of the thumb within the scrollbar's track. The range is expressed in arbitrary units that must be the same as the units used by `computeHorizontalScrollRange()` and `computeHorizontalScrollExtent()`. Default implementation returns 0. If you want to support scroll bars, override `RecyclerView.LayoutManager#computeHorizontalScrollOffset(RecyclerView.State)` in your LayoutManager.
`Int`	`computeHorizontalScrollRange()` Compute the horizontal range that the horizontal scrollbar represents. The range is expressed in arbitrary units that must be the same as the units used by `computeHorizontalScrollExtent()` and `computeHorizontalScrollOffset()`. Default implementation returns 0. If you want to support scroll bars, override `RecyclerView.LayoutManager#computeHorizontalScrollRange(RecyclerView.State)` in your LayoutManager.
`Int`	`computeVerticalScrollExtent()` Compute the vertical extent of the vertical scrollbar's thumb within the vertical range. This value is used to compute the length of the thumb within the scrollbar's track. The range is expressed in arbitrary units that must be the same as the units used by `computeVerticalScrollRange()` and `computeVerticalScrollOffset()`. Default implementation returns 0. If you want to support scroll bars, override `RecyclerView.LayoutManager#computeVerticalScrollExtent(RecyclerView.State)` in your LayoutManager.
`Int`	`computeVerticalScrollOffset()` Compute the vertical offset of the vertical scrollbar's thumb within the vertical range. This value is used to compute the length of the thumb within the scrollbar's track. The range is expressed in arbitrary units that must be the same as the units used by `computeVerticalScrollRange()` and `computeVerticalScrollExtent()`. Default implementation returns 0. If you want to support scroll bars, override `RecyclerView.LayoutManager#computeVerticalScrollOffset(RecyclerView.State)` in your LayoutManager.
`Int`	`computeVerticalScrollRange()` Compute the vertical range that the vertical scrollbar represents. The range is expressed in arbitrary units that must be the same as the units used by `computeVerticalScrollExtent()` and `computeVerticalScrollOffset()`. Default implementation returns 0. If you want to support scroll bars, override `RecyclerView.LayoutManager#computeVerticalScrollRange(RecyclerView.State)` in your LayoutManager.
`Boolean`	`dispatchNestedFling(velocityX: Float, velocityY: Float, consumed: Boolean)`
`Boolean`	`dispatchNestedPreFling(velocityX: Float, velocityY: Float)`
`Boolean`	`dispatchNestedPreScroll(dx: Int, dy: Int, consumed: IntArray?, offsetInWindow: IntArray?)`
`Boolean`	`dispatchNestedPreScroll(dx: Int, dy: Int, consumed: IntArray?, offsetInWindow: IntArray?, type: Int)`
`Boolean`	`dispatchNestedScroll(dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int, offsetInWindow: IntArray?)`
`Boolean`	`dispatchNestedScroll(dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int, offsetInWindow: IntArray?, type: Int)`
`Unit`	`dispatchNestedScroll(dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int, offsetInWindow: IntArray?, type: Int, @NonNull consumed: IntArray)`
`Boolean`	`dispatchPopulateAccessibilityEvent(event: AccessibilityEvent!)`
`Unit`	`dispatchRestoreInstanceState(container: SparseArray<Parcelable!>!)` Override to prevent thawing of any views created by the adapter.
`Unit`	`dispatchSaveInstanceState(container: SparseArray<Parcelable!>!)` Override to prevent freezing of any views created by the adapter.
`Unit`	`draw(c: Canvas!)`
`Boolean`	`drawChild(canvas: Canvas!, child: View!, drawingTime: Long)`
`View?`	`findChildViewUnder(x: Float, y: Float)` Find the topmost view under the given point.
`View?`	`findContainingItemView(@NonNull view: View)` Traverses the ancestors of the given view and returns the item view that contains it and also a direct child of the RecyclerView. This returned view can be used to get the ViewHolder by calling `getChildViewHolder(View)`.
`RecyclerView.ViewHolder?`	`findContainingViewHolder(@NonNull view: View)` Returns the ViewHolder that contains the given view.
`RecyclerView.ViewHolder?`	`findViewHolderForAdapterPosition(position: Int)` Return the ViewHolder for the item in the given position of the data set. Unlike `findViewHolderForLayoutPosition(int)` this method takes into account any pending adapter changes that may not be reflected to the layout yet. On the other hand, if `Adapter#notifyDataSetChanged()` has been called but the new layout has not been calculated yet, this method will return `null` since the new positions of views are unknown until the layout is calculated. This method checks only the children of RecyclerView. If the item at the given `position` is not laid out, it will not create a new one. When the ItemAnimator is running a change animation, there might be 2 ViewHolders representing the same Item. In this case, the updated ViewHolder will be returned.
`RecyclerView.ViewHolder!`