OverFlyingLayoutManager (xui

java.lang.Object
- RecyclerView.LayoutManager
- - com.xuexiang.xui.widget.banner.recycler.layout.OverFlyingLayoutManager

public class OverFlyingLayoutManager
extends RecyclerView.LayoutManager

Since:: 2019/5/29 10:51
Author:: xuexiang

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface OverFlyingLayoutManager.OnPageChangeListener

Nested Classes
Modifier and Type	Class and Description
`static interface`	`OverFlyingLayoutManager.OnPageChangeListener`

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DETERMINE_BY_MAX_AND_MIN`
`static int`	`HORIZONTAL`
`protected int`	`mDecoratedMeasurement`
`protected int`	`mDecoratedMeasurementInOther`
`protected float`	`mInterval`
`protected float`	`mOffset` The offset of property which will change while scrolling
`protected OrientationHelper`	`mOrientationHelper` Many calculations are made depending on orientation.
`protected int`	`mSpaceInOther`
`protected int`	`mSpaceMain`
`static int`	`VERTICAL`

Constructor Summary

Constructors
Constructor and Description
`OverFlyingLayoutManager(android.content.Context context)` Creates a horizontal ViewPagerLayoutManager
`OverFlyingLayoutManager(float minScale, int itemSpace, int orientation)`
`OverFlyingLayoutManager(int orientation, boolean reverseLayout)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected int`	`calItemLeft(android.view.View itemView, float targetOffset)`
`protected int`	`calItemTop(android.view.View itemView, float targetOffset)`
`boolean`	`canScrollHorizontally()`
`boolean`	`canScrollVertically()`
`int`	`computeHorizontalScrollExtent(RecyclerView.State state)`
`int`	`computeHorizontalScrollOffset(RecyclerView.State state)`
`int`	`computeHorizontalScrollRange(RecyclerView.State state)`
`android.graphics.PointF`	`computeScrollVectorForPosition(int targetPosition)`
`int`	`computeVerticalScrollExtent(RecyclerView.State state)`
`int`	`computeVerticalScrollOffset(RecyclerView.State state)`
`int`	`computeVerticalScrollRange(RecyclerView.State state)`
`RecyclerView.LayoutParams`	`generateDefaultLayoutParams()`
`float`	`getAngle()`
`int`	`getCurrentPosition()`
`protected float`	`getDistanceRatio()`
`boolean`	`getEnableBringCenterToFront()`
`boolean`	`getInfinite()`
`int`	`getItemSpace()`
`int`	`getMaxVisibleItemCount()` Returns the max visible item count, `DETERMINE_BY_MAX_AND_MIN` means it haven't been set now And it will use `maxRemoveOffset()` and `minRemoveOffset()` to handle the range
`float`	`getMinScale()`
`int`	`getOffsetToCenter()`
`int`	`getOrientation()` Returns the current orientation of the layout.
`boolean`	`getRecycleChildrenOnDetach()` Returns whether LayoutManager will recycle its children when it is detached from RecyclerView.
`boolean`	`getReverseLayout()` Returns if views are laid out from the opposite direction of the layout.
`boolean`	`getSmoothScrollbarEnabled()` Returns the current state of the smooth scrollbar feature.
`int`	`getTotalSpaceInOther()`
`boolean`	`isIntegerDy()` see `mIntegerDy`
`protected float`	`maxRemoveOffset()` when the target offset reach this, the view will be removed and recycled in `layoutItems(RecyclerView.Recycler)`
`protected float`	`minRemoveOffset()` when the target offset reach this, the view will be removed and recycled in `layoutItems(RecyclerView.Recycler)`
`void`	`onAdapterChanged(RecyclerView.Adapter oldAdapter, RecyclerView.Adapter newAdapter)`
`void`	`onDetachedFromWindow(RecyclerView view, RecyclerView.Recycler recycler)`
`void`	`onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state)`
`void`	`onLayoutCompleted(RecyclerView.State state)`
`void`	`onRestoreInstanceState(android.os.Parcelable state)`
`android.os.Parcelable`	`onSaveInstanceState()`
`protected float`	`propertyChangeWhenScroll(android.view.View itemView)`
`int`	`scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler, RecyclerView.State state)`
`void`	`scrollToPosition(int position)`
`int`	`scrollVerticallyBy(int dy, RecyclerView.Recycler recycler, RecyclerView.State state)`
`void`	`setAngle(float angle)`
`void`	`setEnableBringCenterToFront(boolean bringCenterToTop)`
`void`	`setInfinite(boolean enable)`
`void`	`setIntegerDy(boolean mIntegerDy)` see `mIntegerDy`
`protected float`	`setInterval()`
`void`	`setItemSpace(int itemSpace)`
`protected void`	`setItemViewProperty(android.view.View itemView, float targetOffset)`
`void`	`setMaxVisibleItemCount(int mMaxVisibleItemCount)` Set the max visible item count, `DETERMINE_BY_MAX_AND_MIN` means it haven't been set now And it will use `maxRemoveOffset()` and `minRemoveOffset()` to handle the range
`void`	`setMinScale(float minScale)`
`void`	`setOnPageChangeListener(OverFlyingLayoutManager.OnPageChangeListener onPageChangeListener)`
`void`	`setOrientation(int orientation)` will do its best to keep scroll position.
`void`	`setRecycleChildrenOnDetach(boolean recycleChildrenOnDetach)` Set whether LayoutManager will recycle its children when it is detached from RecyclerView.
`void`	`setReverseLayout(boolean reverseLayout)` Used to reverse item traversal and layout order.
`void`	`setSmoothScrollbarEnabled(boolean enabled)` When smooth scrollbar is enabled, the position and size of the scrollbar thumb is computed based on the number of visible pixels in the visible items.
`protected void`	`setUp()` You can set up your own properties here or change the exist properties like mSpaceMain and mSpaceInOther
`protected float`	`setViewElevation(android.view.View itemView, float targetOffset)` cause elevation is not support below api 21, so you can set your elevation here for supporting it below api 21 or you can just setElevation in `setItemViewProperty(View, float)`
`void`	`smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, int position)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DETERMINE_BY_MAX_AND_MIN
```
public static final int DETERMINE_BY_MAX_AND_MIN
```
    See Also:
    
    Constant Field Values
  - HORIZONTAL
```
public static final int HORIZONTAL
```
  - VERTICAL
```
public static final int VERTICAL
```
  - mDecoratedMeasurement
```
protected int mDecoratedMeasurement
```
  - mDecoratedMeasurementInOther
```
protected int mDecoratedMeasurementInOther
```
  - mSpaceMain
```
protected int mSpaceMain
```
  - mSpaceInOther
```
protected int mSpaceInOther
```
  - mOffset
```
protected float mOffset
```
    The offset of property which will change while scrolling
  - mOrientationHelper
```
protected OrientationHelper mOrientationHelper
```
    Many calculations are made depending on orientation. To keep it clean, this interface helps LinearLayoutManager make those decisions. Based on mOrientation, an implementation is lazily created in ensureLayoutState() method.
  - mInterval
```
protected float mInterval
```
- Constructor Detail
  - OverFlyingLayoutManager
```
public OverFlyingLayoutManager(android.content.Context context)
```
    Creates a horizontal ViewPagerLayoutManager
  - OverFlyingLayoutManager
```
public OverFlyingLayoutManager(int orientation,
                               boolean reverseLayout)
```
    Parameters:
    
    orientation - Layout orientation. Should be HORIZONTAL or VERTICAL
    
    reverseLayout - When set to true, layouts from end to start
  - OverFlyingLayoutManager
```
public OverFlyingLayoutManager(float minScale,
                               int itemSpace,
                               int orientation)
```
- Method Detail
  - getMinScale
```
public float getMinScale()
```
  - setMinScale
```
public void setMinScale(float minScale)
```
  - getAngle
```
public float getAngle()
```
  - setAngle
```
public void setAngle(float angle)
```
  - getItemSpace
```
public int getItemSpace()
```
  - setItemSpace
```
public void setItemSpace(int itemSpace)
```
  - setInterval
```
protected float setInterval()
```
    Returns:
    
    the mInterval of each item's mOffset
  - setItemViewProperty
```
protected void setItemViewProperty(android.view.View itemView,
                                   float targetOffset)
```
  - setViewElevation
```
protected float setViewElevation(android.view.View itemView,
                                 float targetOffset)
```
    cause elevation is not support below api 21, so you can set your elevation here for supporting it below api 21 or you can just setElevation in setItemViewProperty(View, float)
  - generateDefaultLayoutParams
```
public RecyclerView.LayoutParams generateDefaultLayoutParams()
```
  - getRecycleChildrenOnDetach
```
public boolean getRecycleChildrenOnDetach()
```
    Returns whether LayoutManager will recycle its children when it is detached from RecyclerView.
    
    Returns:
    
    true if LayoutManager will recycle its children when it is detached from RecyclerView.
  - setRecycleChildrenOnDetach
```
public void setRecycleChildrenOnDetach(boolean recycleChildrenOnDetach)
```
    Set whether LayoutManager will recycle its children when it is detached from RecyclerView.
    If you are using a RecyclerView.RecycledViewPool, it might be a good idea to set this flag to true so that views will be available to other RecyclerViews immediately.
    Note that, setting this flag will result in a performance drop if RecyclerView is restored.
    
    Parameters:
    
    recycleChildrenOnDetach - Whether children should be recycled in detach or not.
  - onDetachedFromWindow
```
public void onDetachedFromWindow(RecyclerView view,
                                 RecyclerView.Recycler recycler)
```
  - onSaveInstanceState
```
public android.os.Parcelable onSaveInstanceState()
```
  - onRestoreInstanceState
```
public void onRestoreInstanceState(android.os.Parcelable state)
```
  - canScrollHorizontally
```
public boolean canScrollHorizontally()
```
    Returns:
    
    true if getOrientation() is HORIZONTAL
  - canScrollVertically
```
public boolean canScrollVertically()
```
    Returns:
    
    true if getOrientation() is VERTICAL
  - getOrientation
```
public int getOrientation()
```
    Returns the current orientation of the layout.
    
    Returns:
    
    Current orientation, either HORIZONTAL or VERTICAL
    
    See Also:
    
    setOrientation(int)
  - setOrientation
```
public void setOrientation(int orientation)
```
    will do its best to keep scroll position.
    
    Parameters:
    
    orientation - HORIZONTAL or VERTICAL
  - getMaxVisibleItemCount
```
public int getMaxVisibleItemCount()
```
    Returns the max visible item count, DETERMINE_BY_MAX_AND_MIN means it haven't been set now And it will use maxRemoveOffset() and minRemoveOffset() to handle the range
    
    Returns:
    
    Max visible item count
  - setMaxVisibleItemCount
```
public void setMaxVisibleItemCount(int mMaxVisibleItemCount)
```
    Set the max visible item count, DETERMINE_BY_MAX_AND_MIN means it haven't been set now And it will use maxRemoveOffset() and minRemoveOffset() to handle the range
    
    Parameters:
    
    mMaxVisibleItemCount - Max visible item count
  - isIntegerDy
```
public boolean isIntegerDy()
```
    see mIntegerDy
  - setIntegerDy
```
public void setIntegerDy(boolean mIntegerDy)
```
    see mIntegerDy
  - getReverseLayout
```
public boolean getReverseLayout()
```
    Returns if views are laid out from the opposite direction of the layout.
    
    Returns:
    
    If layout is reversed or not.
    
    See Also:
    
    setReverseLayout(boolean)
  - setReverseLayout
```
public void setReverseLayout(boolean reverseLayout)
```
    Used to reverse item traversal and layout order. This behaves similar to the layout change for RTL views. When set to true, first item is laid out at the end of the UI, second item is laid out before it etc.
    For horizontal layouts, it depends on the layout direction. When set to true, If androidx.recyclerview.widget.RecyclerView is LTR, than it will layout from RTL, if androidx.recyclerview.widget.RecyclerView} is RTL, it will layout from LTR.
  - smoothScrollToPosition
```
public void smoothScrollToPosition(RecyclerView recyclerView,
                                   RecyclerView.State state,
                                   int position)
```
  - computeScrollVectorForPosition
```
public android.graphics.PointF computeScrollVectorForPosition(int targetPosition)
```
  - onLayoutChildren
```
public void onLayoutChildren(RecyclerView.Recycler recycler,
                             RecyclerView.State state)
```
  - getTotalSpaceInOther
```
public int getTotalSpaceInOther()
```
  - onLayoutCompleted
```
public void onLayoutCompleted(RecyclerView.State state)
```
  - setUp
```
protected void setUp()
```
    You can set up your own properties here or change the exist properties like mSpaceMain and mSpaceInOther
  - onAdapterChanged
```
public void onAdapterChanged(RecyclerView.Adapter oldAdapter,
                             RecyclerView.Adapter newAdapter)
```
  - scrollToPosition
```
public void scrollToPosition(int position)
```
  - computeHorizontalScrollOffset
```
public int computeHorizontalScrollOffset(RecyclerView.State state)
```
  - computeVerticalScrollOffset
```
public int computeVerticalScrollOffset(RecyclerView.State state)
```
  - computeHorizontalScrollExtent
```
public int computeHorizontalScrollExtent(RecyclerView.State state)
```
  - computeVerticalScrollExtent
```
public int computeVerticalScrollExtent(RecyclerView.State state)
```
  - computeHorizontalScrollRange
```
public int computeHorizontalScrollRange(RecyclerView.State state)
```
  - computeVerticalScrollRange
```
public int computeVerticalScrollRange(RecyclerView.State state)
```
  - scrollHorizontallyBy
```
public int scrollHorizontallyBy(int dx,
                                RecyclerView.Recycler recycler,
                                RecyclerView.State state)
```
  - scrollVerticallyBy
```
public int scrollVerticallyBy(int dy,
                              RecyclerView.Recycler recycler,
                              RecyclerView.State state)
```
  - calItemLeft
```
protected int calItemLeft(android.view.View itemView,
                          float targetOffset)
```
  - calItemTop
```
protected int calItemTop(android.view.View itemView,
                         float targetOffset)
```
  - maxRemoveOffset
```
protected float maxRemoveOffset()
```
    when the target offset reach this, the view will be removed and recycled in layoutItems(RecyclerView.Recycler)
  - minRemoveOffset
```
protected float minRemoveOffset()
```
    when the target offset reach this, the view will be removed and recycled in layoutItems(RecyclerView.Recycler)
  - propertyChangeWhenScroll
```
protected float propertyChangeWhenScroll(android.view.View itemView)
```
  - getDistanceRatio
```
protected float getDistanceRatio()
```
  - getCurrentPosition
```
public int getCurrentPosition()
```
  - getOffsetToCenter
```
public int getOffsetToCenter()
```
    Returns:
    
    the dy between center and current position
  - setOnPageChangeListener
```
public void setOnPageChangeListener(OverFlyingLayoutManager.OnPageChangeListener onPageChangeListener)
```
  - setInfinite
```
public void setInfinite(boolean enable)
```
  - getInfinite
```
public boolean getInfinite()
```
  - setSmoothScrollbarEnabled
```
public void setSmoothScrollbarEnabled(boolean enabled)
```
    When smooth scrollbar is enabled, the position and size of the scrollbar thumb is computed based on the number of visible pixels in the visible items. This however assumes that all list items have similar or equal widths or heights (depending on list orientation). If you use a list in which items have different dimensions, the scrollbar will change appearance as the user scrolls through the list. To avoid this issue, you need to disable this property.
    When smooth scrollbar is disabled, the position and size of the scrollbar thumb is based solely on the number of items in the mAdapter and the position of the visible items inside the mAdapter. This provides a stable scrollbar as the user navigates through a list of items with varying widths / heights.
    
    Parameters:
    
    enabled - Whether or not to enable smooth scrollbar.
    
    See Also:
    
    setSmoothScrollbarEnabled(boolean)
  - setEnableBringCenterToFront
```
public void setEnableBringCenterToFront(boolean bringCenterToTop)
```
  - getEnableBringCenterToFront
```
public boolean getEnableBringCenterToFront()
```
  - getSmoothScrollbarEnabled
```
public boolean getSmoothScrollbarEnabled()
```
    Returns the current state of the smooth scrollbar feature. It is enabled by default.
    
    Returns:
    
    True if smooth scrollbar is enabled, false otherwise.
    
    See Also:
    
    setSmoothScrollbarEnabled(boolean)

Class OverFlyingLayoutManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DETERMINE_BY_MAX_AND_MIN

HORIZONTAL

VERTICAL

mDecoratedMeasurement

mDecoratedMeasurementInOther

mSpaceMain

mSpaceInOther

mOffset

mOrientationHelper

mInterval

Constructor Detail

OverFlyingLayoutManager

OverFlyingLayoutManager

OverFlyingLayoutManager

Method Detail

getMinScale

setMinScale

getAngle

setAngle

getItemSpace

setItemSpace

setInterval

setItemViewProperty

setViewElevation

generateDefaultLayoutParams

getRecycleChildrenOnDetach

setRecycleChildrenOnDetach

onDetachedFromWindow

onSaveInstanceState

onRestoreInstanceState

canScrollHorizontally

canScrollVertically

getOrientation

setOrientation

getMaxVisibleItemCount

setMaxVisibleItemCount

isIntegerDy

setIntegerDy

getReverseLayout

setReverseLayout

smoothScrollToPosition

computeScrollVectorForPosition

onLayoutChildren

getTotalSpaceInOther

onLayoutCompleted

setUp

onAdapterChanged

scrollToPosition

computeHorizontalScrollOffset

computeVerticalScrollOffset

computeHorizontalScrollExtent

computeVerticalScrollExtent

computeHorizontalScrollRange

computeVerticalScrollRange

scrollHorizontallyBy

scrollVerticallyBy

calItemLeft

calItemTop

maxRemoveOffset

minRemoveOffset

propertyChangeWhenScroll

getDistanceRatio

getCurrentPosition

getOffsetToCenter

setOnPageChangeListener

setInfinite

getInfinite

setSmoothScrollbarEnabled

setEnableBringCenterToFront

getEnableBringCenterToFront

getSmoothScrollbarEnabled