BannerLayoutManager (xui_lib 1.0.9-support API)

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

```
public class BannerLayoutManager
extends RecyclerView.LayoutManager
```
An implementation of RecyclerView.LayoutManager which behaves like view pager. Please make sure your child view have the same size.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface BannerLayoutManager.OnPageChangeListener

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

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`DETERMINE_BY_MAX_AND_MIN`
`static int`	`HORIZONTAL`
`protected static int`	`INVALID_SIZE`
`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
`BannerLayoutManager(android.content.Context context)` Creates a horizontal ViewPagerLayoutManager
`BannerLayoutManager(android.content.Context context, int orientation)`
`BannerLayoutManager(android.content.Context context, 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)`
`int`	`computeVerticalScrollExtent(RecyclerView.State state)`
`int`	`computeVerticalScrollOffset(RecyclerView.State state)`
`int`	`computeVerticalScrollRange(RecyclerView.State state)`
`android.view.View`	`findViewByPosition(int position)`
`RecyclerView.LayoutParams`	`generateDefaultLayoutParams()`
`int`	`getCurrentPosition()`
`protected float`	`getDistanceRatio()`
`int`	`getDistanceToBottom()`
`boolean`	`getEnableBringCenterToFront()`
`boolean`	`getInfinite()`
`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
`int`	`getOffsetToCenter()`
`int`	`getOffsetToPosition(int position)`
`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()`
`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)`
`boolean`	`onAddFocusables(RecyclerView recyclerView, java.util.ArrayList<android.view.View> views, int direction, int focusableMode)`
`void`	`onDetachedFromWindow(RecyclerView view, RecyclerView.Recycler recycler)`
`android.view.View`	`onFocusSearchFailed(android.view.View focused, int focusDirection, RecyclerView.Recycler recycler, RecyclerView.State state)`
`void`	`onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state)`
`void`	`onLayoutCompleted(RecyclerView.State state)`
`void`	`onRestoreInstanceState(android.os.Parcelable state)`
`android.os.Parcelable`	`onSaveInstanceState()`
`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`	`setCenterScale(float centerScale)`
`void`	`setDistanceToBottom(int mDistanceToBottom)`
`void`	`setEnableBringCenterToFront(boolean bringCenterToTop)`
`void`	`setInfinite(boolean enable)`
`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`	`setMoveSpeed(float moveSpeed)`
`void`	`setOnPageChangeListener(BannerLayoutManager.OnPageChangeListener onPageChangeListener)`
`void`	`setOrientation(int orientation)` Sets the orientation of the layout.
`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.
`void`	`setSmoothScrollInterpolator(android.view.animation.Interpolator smoothScrollInterpolator)`
`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
```
  - INVALID_SIZE
```
protected static final int INVALID_SIZE
```
    See Also:
    
    Constant Field Values
  - 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
  - BannerLayoutManager
```
public BannerLayoutManager(android.content.Context context)
```
    Creates a horizontal ViewPagerLayoutManager
  - BannerLayoutManager
```
public BannerLayoutManager(android.content.Context context,
                           int orientation)
```
    Parameters:
    
    orientation - Layout orientation. Should be HORIZONTAL or VERTICAL
  - BannerLayoutManager
```
public BannerLayoutManager(android.content.Context context,
                           int orientation,
                           boolean reverseLayout)
```
- Method Detail
  - getDistanceRatio
```
protected float getDistanceRatio()
```
  - setInterval
```
protected float setInterval()
```
  - setItemSpace
```
public void setItemSpace(int itemSpace)
```
  - setCenterScale
```
public void setCenterScale(float centerScale)
```
  - setMoveSpeed
```
public void setMoveSpeed(float moveSpeed)
```
  - 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)
```
    Sets the orientation of the layout. BannerLayoutManager 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
  - 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 android.support.v7.widget.RecyclerView is LTR, than it will layout from RTL, if android.support.v7.widget.RecyclerView} is RTL, it will layout from LTR.
  - setSmoothScrollInterpolator
```
public void setSmoothScrollInterpolator(android.view.animation.Interpolator smoothScrollInterpolator)
```
  - smoothScrollToPosition
```
public void smoothScrollToPosition(RecyclerView recyclerView,
                                   RecyclerView.State state,
                                   int position)
```
  - scrollToPosition
```
public void scrollToPosition(int position)
```
  - onLayoutChildren
```
public void onLayoutChildren(RecyclerView.Recycler recycler,
                             RecyclerView.State state)
```
  - getTotalSpaceInOther
```
public int getTotalSpaceInOther()
```
  - onLayoutCompleted
```
public void onLayoutCompleted(RecyclerView.State state)
```
  - onAddFocusables
```
public boolean onAddFocusables(RecyclerView recyclerView,
                               java.util.ArrayList<android.view.View> views,
                               int direction,
                               int focusableMode)
```
  - onFocusSearchFailed
```
public android.view.View onFocusSearchFailed(android.view.View focused,
                                             int focusDirection,
                                             RecyclerView.Recycler recycler,
                                             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)
```
  - 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)
  - getCurrentPosition
```
public int getCurrentPosition()
```
  - findViewByPosition
```
public android.view.View findViewByPosition(int position)
```
  - getOffsetToCenter
```
public int getOffsetToCenter()
```
    Returns:
    
    the dy between center and current position
  - getOffsetToPosition
```
public int getOffsetToPosition(int position)
```
  - setOnPageChangeListener
```
public void setOnPageChangeListener(BannerLayoutManager.OnPageChangeListener onPageChangeListener)
```
  - setInfinite
```
public void setInfinite(boolean enable)
```
  - getInfinite
```
public boolean getInfinite()
```
  - getDistanceToBottom
```
public int getDistanceToBottom()
```
  - setDistanceToBottom
```
public void setDistanceToBottom(int mDistanceToBottom)
```
  - 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 BannerLayoutManager

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

INVALID_SIZE

mDecoratedMeasurement

mDecoratedMeasurementInOther

mSpaceMain

mSpaceInOther

mOffset

mOrientationHelper

mInterval

Constructor Detail

BannerLayoutManager

BannerLayoutManager

BannerLayoutManager

Method Detail

getDistanceRatio

setInterval

setItemSpace

setCenterScale

setMoveSpeed

setItemViewProperty

setViewElevation

generateDefaultLayoutParams

getRecycleChildrenOnDetach

setRecycleChildrenOnDetach

onDetachedFromWindow

onSaveInstanceState

onRestoreInstanceState

canScrollHorizontally

canScrollVertically

getOrientation

setOrientation

getMaxVisibleItemCount

setMaxVisibleItemCount

getReverseLayout

setReverseLayout

setSmoothScrollInterpolator

smoothScrollToPosition

scrollToPosition

onLayoutChildren

getTotalSpaceInOther

onLayoutCompleted

onAddFocusables

onFocusSearchFailed

setUp

onAdapterChanged

computeHorizontalScrollOffset

computeVerticalScrollOffset

computeHorizontalScrollExtent

computeVerticalScrollExtent

computeHorizontalScrollRange

computeVerticalScrollRange

scrollHorizontallyBy

scrollVerticallyBy

calItemLeft

calItemTop

maxRemoveOffset

minRemoveOffset

getCurrentPosition

findViewByPosition

getOffsetToCenter

getOffsetToPosition

setOnPageChangeListener

setInfinite

getInfinite

getDistanceToBottom

setDistanceToBottom

setSmoothScrollbarEnabled

setEnableBringCenterToFront

getEnableBringCenterToFront

getSmoothScrollbarEnabled