text stringlengths 9 39.2M | dir stringlengths 26 295 | lang stringclasses 185
values | created_date timestamp[us] | updated_date timestamp[us] | repo_name stringlengths 1 97 | repo_full_name stringlengths 7 106 | star int64 1k 183k | len_tokens int64 1 13.8M |
|---|---|---|---|---|---|---|---|---|
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.view.View;
class RTLDownLayouter extends AbstractLayouter {
private boolean isPurged;
private RTLDownLayouter(Builder builder) {
super(builder);
}
public static Builder newBuilder() {
return new Builder();
}
@Override
void onPreLayout() {
if (!rowViews.isEmpty()) {
//todo this isn't great place for that. Should be refactored somehow
if (!isPurged) {
isPurged = true;
getCacheStorage().purgeCacheFromPosition(getLayoutManager().getPosition(rowViews.get(0).second));
}
getCacheStorage().storeRow(rowViews);
}
}
@Override
void onAfterLayout() {
//go to next row, increase top coordinate, reset left
viewRight = getCanvasRightBorder();
viewTop = viewBottom;
}
@Override
boolean isAttachedViewFromNewRow(View view) {
int topOfCurrentView = getLayoutManager().getDecoratedTop(view);
int rightOfCurrentVIew = getLayoutManager().getDecoratedRight(view);
return viewBottom <= topOfCurrentView
&& rightOfCurrentVIew > viewRight;
}
@Override
Rect createViewRect(View view) {
Rect viewRect = new Rect(viewRight - getCurrentViewWidth(), viewTop, viewRight, viewTop + getCurrentViewHeight());
viewRight = viewRect.left;
viewBottom = Math.max(viewBottom, viewRect.bottom);
return viewRect;
}
@Override
boolean isReverseOrder() {
return false;
}
@Override
public void onInterceptAttachView(View view) {
viewTop = getLayoutManager().getDecoratedTop(view);
viewRight = getLayoutManager().getDecoratedLeft(view);
viewBottom = Math.max(viewBottom, getLayoutManager().getDecoratedBottom(view));
}
@Override
public int getStartRowBorder() {
return getViewTop();
}
@Override
public int getEndRowBorder() {
return getViewBottom();
}
@Override
public int getRowLength() {
return getCanvasRightBorder() - viewRight;
}
public static final class Builder extends AbstractLayouter.Builder {
private Builder() {
}
@NonNull
public RTLDownLayouter createLayouter() {
return new RTLDownLayouter(this);
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RTLDownLayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 546 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.Nullable;
import android.util.Pair;
import android.view.View;
import java.util.List;
public interface ILayouter {
/** add views from current row to layout*/
void layoutRow();
/** calculate view positions, view won't be actually added to layout when calling this method
* @return true if view successfully placed, false if view can't be placed because out of space on screen and have to be recycled */
boolean placeView(View view);
/** Read layouter state from current attached view. We need only last of it, but we can't determine here which is last.
* Based on characteristics of last attached view, layouter algorithm will be able to continue placing from it.
* This method have to be called on attaching view
* @return * @return true if view successfully attached, false if view can't be attached because out of space on screen */
boolean onAttachView(View view);
/** @return size of current row*/
int getRowSize();
/** @return top of current row*/
int getViewTop();
/** @return bottom of current row */
int getViewBottom();
/** @return size of previous row*/
int getPreviousRowSize();
List<Item> getCurrentRowItems();
Rect getRowRect();
void addLayouterListener(ILayouterListener layouterListener);
void removeLayouterListener(ILayouterListener layouterListener);
AbstractPositionIterator positionIterator();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ILayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 322 |
```java
package com.beloo.widget.chipslayoutmanager;
import android.content.Context;
import android.graphics.Rect;
import android.os.Parcelable;
import android.support.annotation.IntRange;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.RestrictTo;
import android.support.annotation.VisibleForTesting;
import android.support.v4.view.ViewCompat;
import android.support.v7.widget.RecyclerView;
import android.util.SparseArray;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.anchor.IAnchorFactory;
import com.beloo.widget.chipslayoutmanager.layouter.ColumnsStateFactory;
import com.beloo.widget.chipslayoutmanager.layouter.ICanvas;
import com.beloo.widget.chipslayoutmanager.layouter.IMeasureSupporter;
import com.beloo.widget.chipslayoutmanager.layouter.IStateFactory;
import com.beloo.widget.chipslayoutmanager.layouter.MeasureSupporter;
import com.beloo.widget.chipslayoutmanager.layouter.RowsStateFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.EmptyRowBreaker;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IRowBreaker;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.cache.ViewCacheFactory;
import com.beloo.widget.chipslayoutmanager.gravity.CenterChildGravity;
import com.beloo.widget.chipslayoutmanager.gravity.CustomGravityResolver;
import com.beloo.widget.chipslayoutmanager.gravity.IChildGravityResolver;
import com.beloo.widget.chipslayoutmanager.layouter.LayouterFactory;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractPositionIterator;
import com.beloo.widget.chipslayoutmanager.layouter.ILayouter;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.AbstractCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.InfiniteCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.PlacerFactory;
import com.beloo.widget.chipslayoutmanager.util.log.IFillLogger;
import com.beloo.widget.chipslayoutmanager.util.log.LoggerFactory;
import com.beloo.widget.chipslayoutmanager.util.AssertionUtils;
import com.beloo.widget.chipslayoutmanager.util.LayoutManagerUtil;
import com.beloo.widget.chipslayoutmanager.util.log.Log;
import com.beloo.widget.chipslayoutmanager.util.log.LogSwitcherFactory;
import com.beloo.widget.chipslayoutmanager.util.testing.EmptySpy;
import com.beloo.widget.chipslayoutmanager.util.testing.ISpy;
import java.util.Locale;
public class ChipsLayoutManager extends RecyclerView.LayoutManager implements IChipsLayoutManagerContract,
IStateHolder,
ScrollingController.IScrollerListener {
///////////////////////////////////////////////////////////////////////////
// orientation types
///////////////////////////////////////////////////////////////////////////
@SuppressWarnings("WeakerAccess")
public static final int HORIZONTAL = 1;
@SuppressWarnings("WeakerAccess")
public static final int VERTICAL = 2;
///////////////////////////////////////////////////////////////////////////
// row strategy types
///////////////////////////////////////////////////////////////////////////
@SuppressWarnings("WeakerAccess")
public static final int STRATEGY_DEFAULT = 1;
@SuppressWarnings("WeakerAccess")
public static final int STRATEGY_FILL_VIEW = 2;
@SuppressWarnings("WeakerAccess")
public static final int STRATEGY_FILL_SPACE = 4;
@SuppressWarnings("WeakerAccess")
public static final int STRATEGY_CENTER = 5;
@SuppressWarnings("WeakerAccess")
public static final int STRATEGY_CENTER_DENSE = 6;
///////////////////////////////////////////////////////////////////////////
// inner constants
///////////////////////////////////////////////////////////////////////////
private static final String TAG = ChipsLayoutManager.class.getSimpleName();
private static final int INT_ROW_SIZE_APPROXIMATELY_FOR_CACHE = 10;
private static final int APPROXIMATE_ADDITIONAL_ROWS_COUNT = 5;
/**
* coefficient to support fast scrolling, caching views only for one row may not be enough
*/
private static final float FAST_SCROLLING_COEFFICIENT = 2;
/** delegate which represents available canvas for drawing views according to layout*/
private ICanvas canvas;
private IDisappearingViewsManager disappearingViewsManager;
/** iterable over views added to RecyclerView */
private ChildViewsIterable childViews = new ChildViewsIterable(this);
private SparseArray<View> childViewPositions = new SparseArray<>();
///////////////////////////////////////////////////////////////////////////
// contract parameters
///////////////////////////////////////////////////////////////////////////
/** determine gravity of child inside row*/
private IChildGravityResolver childGravityResolver;
private boolean isScrollingEnabledContract = true;
/** strict restriction of max count of views in particular row */
private Integer maxViewsInRow = null;
/** determines whether LM should break row from view position */
private IRowBreaker rowBreaker = new EmptyRowBreaker();
//--- end contract parameters
/** layoutOrientation of layout. Could have HORIZONTAL or VERTICAL style */
@Orientation
private int layoutOrientation = HORIZONTAL;
@RowStrategy
private int rowStrategy = STRATEGY_DEFAULT;
private boolean isStrategyAppliedWithLastRow;
/** @see #setSmoothScrollbarEnabled(boolean). True by default */
private boolean isSmoothScrollbarEnabled = false;
///////////////////////////////////////////////////////////////////////////
// cache
///////////////////////////////////////////////////////////////////////////
/** store positions of placed view to know when LM should break row while moving back
* this cache mostly needed to place views when scrolling down to the same places, where they have been previously */
private IViewCacheStorage viewPositionsStorage;
/**
* when scrolling reached this position {@link ChipsLayoutManager} is able to restore items layout according to cached items with positions above.
* That layout would exactly correspond to current item view situation
*/
@Nullable
private Integer cacheNormalizationPosition = null;
/**
* store detached views to probably reattach it if them still visible.
* Used while scrolling
*/
private SparseArray<View> viewCache = new SparseArray<>();
/**
* storing state due layoutOrientation changes
*/
private ParcelableContainer container = new ParcelableContainer();
///////////////////////////////////////////////////////////////////////////
// loggers
///////////////////////////////////////////////////////////////////////////
private IFillLogger logger;
//--- end loggers
/**
* is layout in RTL mode. Variable needed to detect mode changes
*/
private boolean isLayoutRTL = false;
/**
* current device layoutOrientation
*/
@DeviceOrientation
private int orientation;
///////////////////////////////////////////////////////////////////////////
// borders
///////////////////////////////////////////////////////////////////////////
/**
* stored current anchor view due to scroll state changes
*/
private AnchorViewState anchorView;
///////////////////////////////////////////////////////////////////////////
// state-dependent
///////////////////////////////////////////////////////////////////////////
/** factory for state-dependent layouter factories*/
private IStateFactory stateFactory;
/** manage auto-measuring */
private IMeasureSupporter measureSupporter;
/** factory which could retrieve anchorView on which layouting based*/
private IAnchorFactory anchorFactory;
/** manage scrolling of layout manager according to current state */
private IScrollingController scrollingController;
//--- end state-dependent vars
/** factory for placers factories*/
private PlacerFactory placerFactory = new PlacerFactory(this);
/** used for testing purposes to spy for {@link ChipsLayoutManager} behaviour */
private ISpy spy = new EmptySpy();
private boolean isAfterPreLayout;
@SuppressWarnings("WeakerAccess")
@VisibleForTesting
ChipsLayoutManager(Context context) {
@DeviceOrientation
int orientation = context.getResources().getConfiguration().orientation;
this.orientation = orientation;
LoggerFactory loggerFactory = new LoggerFactory();
logger = loggerFactory.getFillLogger(viewCache);
viewPositionsStorage = new ViewCacheFactory(this).createCacheStorage();
measureSupporter = new MeasureSupporter(this);
setAutoMeasureEnabled(true);
}
///////////////////////////////////////////////////////////////////////////
// ChipsLayoutManager contract methods
///////////////////////////////////////////////////////////////////////////
public static Builder newBuilder(Context context) {
if (context == null) throw new IllegalArgumentException("you have passed null context to builder");
return new ChipsLayoutManager(context).new StrategyBuilder();
}
public IChildGravityResolver getChildGravityResolver() {
return childGravityResolver;
}
/** use it to strictly disable scrolling.
* If scrolling enabled it would be disabled in case all items fit on the screen */
@Override
public void setScrollingEnabledContract(boolean isEnabled) {
isScrollingEnabledContract = isEnabled;
}
@Override
public boolean isScrollingEnabledContract() {
return isScrollingEnabledContract;
}
/**
* change max count of row views in runtime
*/
@SuppressWarnings("unused")
public void setMaxViewsInRow(@IntRange(from = 1) Integer maxViewsInRow) {
if (maxViewsInRow < 1)
throw new IllegalArgumentException("maxViewsInRow should be positive, but is = " + maxViewsInRow);
this.maxViewsInRow = maxViewsInRow;
onRuntimeLayoutChanges();
}
private void onRuntimeLayoutChanges() {
cacheNormalizationPosition = 0;
viewPositionsStorage.purge();
requestLayoutWithAnimations();
}
@Override
public Integer getMaxViewsInRow() {
return maxViewsInRow;
}
@Override
public IRowBreaker getRowBreaker() {
return rowBreaker;
}
@Override
@RowStrategy
public int getRowStrategyType() {
return rowStrategy;
}
///////////////////////////////////////////////////////////////////////////
// non-contract public methods. Used only for inner purposes
///////////////////////////////////////////////////////////////////////////
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public boolean isStrategyAppliedWithLastRow() {
return isStrategyAppliedWithLastRow;
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public IViewCacheStorage getViewPositionsStorage() {
return viewPositionsStorage;
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public ICanvas getCanvas() {
return canvas;
}
@NonNull
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
AnchorViewState getAnchor() {
return anchorView;
}
@VisibleForTesting
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
void setSpy(ISpy spy) {
this.spy = spy;
}
///////////////////////////////////////////////////////////////////////////
// builder
///////////////////////////////////////////////////////////////////////////
//create decorator if any other builders would be added
@SuppressWarnings("WeakerAccess")
public class StrategyBuilder extends Builder {
/** @param withLastRow true, if row strategy should be applied to last row.
* @see Builder#setRowStrategy(int) */
@SuppressWarnings("unused")
public Builder withLastRow(boolean withLastRow) {
ChipsLayoutManager.this.isStrategyAppliedWithLastRow = withLastRow;
return this;
}
}
@SuppressWarnings("WeakerAccess")
public class Builder {
@SpanLayoutChildGravity
private Integer gravity;
private Builder() {
}
/**
* set vertical gravity in a row for all children. Default = CENTER_VERTICAL
*/
@SuppressWarnings({"unused", "WeakerAccess"})
public Builder setChildGravity(@SpanLayoutChildGravity int gravity) {
this.gravity = gravity;
return this;
}
/**
* set gravity resolver in case you need special gravity for items. This method have priority over {@link #setChildGravity(int)}
*/
@SuppressWarnings("unused")
public Builder setGravityResolver(@NonNull IChildGravityResolver gravityResolver) {
AssertionUtils.assertNotNull(gravityResolver, "gravity resolver couldn't be null");
childGravityResolver = gravityResolver;
return this;
}
/**
* strictly disable scrolling if needed
*/
@SuppressWarnings("unused")
public Builder setScrollingEnabled(boolean isEnabled) {
ChipsLayoutManager.this.setScrollingEnabledContract(isEnabled);
return this;
}
/** row strategy for views in completed row.
* Any row has some space left, where is impossible to place the next view, because that space is too small.
* But we could distribute that space for available views in that row
* @param rowStrategy is a mode of distribution left space<br/>
* {@link #STRATEGY_DEFAULT} is used by default. Left space is placed at the end of the row.<br/>
* {@link #STRATEGY_FILL_VIEW} available space is distributed among views<br/>
* {@link #STRATEGY_FILL_SPACE} available space is distributed among spaces between views, start & end views are docked to a nearest border<br/>
* {@link #STRATEGY_CENTER} available space is distributed among spaces between views, start & end spaces included. Views are placed in center of canvas<br/>
* {@link #STRATEGY_CENTER_DENSE} available space is distributed among start & end spaces. Views are placed in center of canvas<br/>
* <br/>
* In such layouts by default last row isn't considered completed. So strategy isn't applied for last row.<br/>
* But you can also enable opposite behaviour.
* @see StrategyBuilder#withLastRow(boolean)
*/
@SuppressWarnings("unused")
public StrategyBuilder setRowStrategy(@RowStrategy int rowStrategy) {
ChipsLayoutManager.this.rowStrategy = rowStrategy;
return (StrategyBuilder) this;
}
/**
* set maximum possible count of views in row
*/
@SuppressWarnings("unused")
public Builder setMaxViewsInRow(@IntRange(from = 1) int maxViewsInRow) {
if (maxViewsInRow < 1)
throw new IllegalArgumentException("maxViewsInRow should be positive, but is = " + maxViewsInRow);
ChipsLayoutManager.this.maxViewsInRow = maxViewsInRow;
return this;
}
/** @param breaker override to determine whether ChipsLayoutManager should breaks row due to position of view. */
@SuppressWarnings("unused")
public Builder setRowBreaker(@NonNull IRowBreaker breaker) {
AssertionUtils.assertNotNull(breaker, "breaker couldn't be null");
ChipsLayoutManager.this.rowBreaker = breaker;
return this;
}
/** @param orientation of layout manager. Could be {@link #HORIZONTAL} or {@link #VERTICAL}
* {@link #HORIZONTAL} by default */
public Builder setOrientation(@Orientation int orientation) {
if (orientation != HORIZONTAL && orientation != VERTICAL) {
return this;
}
ChipsLayoutManager.this.layoutOrientation = orientation;
return this;
}
/**
* create SpanLayoutManager
*/
public ChipsLayoutManager build() {
// setGravityResolver always have priority
if (childGravityResolver == null) {
if (gravity != null) {
childGravityResolver = new CustomGravityResolver(gravity);
} else {
childGravityResolver = new CenterChildGravity();
}
}
stateFactory = layoutOrientation == HORIZONTAL ? new RowsStateFactory(ChipsLayoutManager.this) : new ColumnsStateFactory(ChipsLayoutManager.this);
canvas = stateFactory.createCanvas();
anchorFactory = stateFactory.anchorFactory();
scrollingController = stateFactory.scrollingController();
anchorView = anchorFactory.createNotFound();
disappearingViewsManager = new DisappearingViewsManager(canvas, childViews, stateFactory);
return ChipsLayoutManager.this;
}
}
/**
* {@inheritDoc}
*/
@Override
public RecyclerView.LayoutParams generateDefaultLayoutParams() {
return new RecyclerView.LayoutParams(
RecyclerView.LayoutParams.WRAP_CONTENT,
RecyclerView.LayoutParams.WRAP_CONTENT);
}
private void requestLayoutWithAnimations() {
LayoutManagerUtil.requestLayoutWithAnimations(this);
}
///////////////////////////////////////////////////////////////////////////
// instance state
///////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
@Override
public void onRestoreInstanceState(Parcelable state) {
container = (ParcelableContainer) state;
anchorView = container.getAnchorViewState();
if (orientation != container.getOrientation()) {
//orientation have been changed, clear anchor rect
int anchorPos = anchorView.getPosition();
anchorView = anchorFactory.createNotFound();
anchorView.setPosition(anchorPos);
}
viewPositionsStorage.onRestoreInstanceState(container.getPositionsCache(orientation));
cacheNormalizationPosition = container.getNormalizationPosition(orientation);
Log.d(TAG, "RESTORE. last cache position before cleanup = " + viewPositionsStorage.getLastCachePosition());
if (cacheNormalizationPosition != null) {
viewPositionsStorage.purgeCacheFromPosition(cacheNormalizationPosition);
}
viewPositionsStorage.purgeCacheFromPosition(anchorView.getPosition());
Log.d(TAG, "RESTORE. anchor position =" + anchorView.getPosition());
Log.d(TAG, "RESTORE. layoutOrientation = " + orientation + " normalizationPos = " + cacheNormalizationPosition);
Log.d(TAG, "RESTORE. last cache position = " + viewPositionsStorage.getLastCachePosition());
}
/**
* {@inheritDoc}
*/
@Override
public Parcelable onSaveInstanceState() {
container.putAnchorViewState(anchorView);
container.putPositionsCache(orientation, viewPositionsStorage.onSaveInstanceState());
container.putOrientation(orientation);
Log.d(TAG, "STORE. last cache position =" + viewPositionsStorage.getLastCachePosition());
Integer storedNormalizationPosition = cacheNormalizationPosition != null ? cacheNormalizationPosition : viewPositionsStorage.getLastCachePosition();
Log.d(TAG, "STORE. layoutOrientation = " + orientation + " normalizationPos = " + storedNormalizationPosition);
container.putNormalizationPosition(orientation, storedNormalizationPosition);
return container;
}
/**
* {@inheritDoc}
*/
@Override
public boolean supportsPredictiveItemAnimations() {
return true;
}
///////////////////////////////////////////////////////////////////////////
// visible items
///////////////////////////////////////////////////////////////////////////
/** returns count of completely visible views
* @see #findFirstCompletelyVisibleItemPosition() ()
* @see #findLastCompletelyVisibleItemPosition() */
@SuppressWarnings("WeakerAccess")
public int getCompletelyVisibleViewsCount() {
int visibleViewsCount = 0;
for (View child : childViews) {
if (canvas.isFullyVisible(child)){
visibleViewsCount++;
}
}
return visibleViewsCount;
}
///////////////////////////////////////////////////////////////////////////
// positions contract
///////////////////////////////////////////////////////////////////////////
/**
* Returns the adapter position of the first visible view. This position does not include
* adapter changes that were dispatched after the last layout pass.
* If RecyclerView has item decorators, they will be considered in calculations as well.
* <p>
* LayoutManager may pre-cache some views that are not necessarily visible. Those views
* are ignored in this method.
*
* @return The adapter position of the first visible item or {@link RecyclerView#NO_POSITION} if
* there aren't any visible items.
* @see #findFirstCompletelyVisibleItemPosition()
* @see #findLastVisibleItemPosition()
*/
@Override
public int findFirstVisibleItemPosition() {
if (getChildCount() == 0)
return RecyclerView.NO_POSITION;
return canvas.getMinPositionOnScreen();
}
/**
* Returns the adapter position of the first fully visible view. This position does not include
* adapter changes that were dispatched after the last layout pass.
*
* @return The adapter position of the first fully visible item or
* {@link RecyclerView#NO_POSITION} if there aren't any visible items.
* @see #findFirstVisibleItemPosition()
* @see #findLastCompletelyVisibleItemPosition()
*/
@Override
public int findFirstCompletelyVisibleItemPosition() {
for (View view : childViews) {
Rect rect = canvas.getViewRect(view);
if (!canvas.isFullyVisible(rect)) continue;
if (canvas.isInside(rect)) {
return getPosition(view);
}
}
return RecyclerView.NO_POSITION;
}
/**
* Returns the adapter position of the last visible view. This position does not include
* adapter changes that were dispatched after the last layout pass.
* If RecyclerView has item decorators, they will be considered in calculations as well.
* <p>
* LayoutManager may pre-cache some views that are not necessarily visible. Those views
* are ignored in this method.
*
* @return The adapter position of the last visible view or {@link RecyclerView#NO_POSITION} if
* there aren't any visible items.
* @see #findLastCompletelyVisibleItemPosition()
* @see #findFirstVisibleItemPosition()
*/
@Override
public int findLastVisibleItemPosition() {
if (getChildCount() == 0)
return RecyclerView.NO_POSITION;
return canvas.getMaxPositionOnScreen();
}
/**
* Returns the adapter position of the last fully visible view. This position does not include
* adapter changes that were dispatched after the last layout pass.
*
* @return The adapter position of the last fully visible view or
* {@link RecyclerView#NO_POSITION} if there aren't any visible items.
* @see #findLastVisibleItemPosition()
* @see #findFirstCompletelyVisibleItemPosition()
*/
@Override
public int findLastCompletelyVisibleItemPosition() {
for (int i = getChildCount() - 1; i >=0; i--) {
View view = getChildAt(i);
Rect rect = canvas.getViewRect(view);
if (!canvas.isFullyVisible(rect)) continue;
if (canvas.isInside(view)) {
return getPosition(view);
}
}
return RecyclerView.NO_POSITION;
}
/** @return child for requested position. Null if that child haven't added to layout manager*/
@Nullable
View getChildWithPosition(int position) {
return childViewPositions.get(position);
}
///////////////////////////////////////////////////////////////////////////
// orientation
///////////////////////////////////////////////////////////////////////////
/**
* @return true if RTL mode enabled in RecyclerView
*/
public boolean isLayoutRTL() {
return getLayoutDirection() == ViewCompat.LAYOUT_DIRECTION_RTL;
}
@Override
@Orientation
public int layoutOrientation() {
return layoutOrientation;
}
///////////////////////////////////////////////////////////////////////////
// layouting
///////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
@Override
public int getItemCount() {
//in pre-layouter drawing we need item count with items will be actually deleted to pre-draw appearing items properly
return super.getItemCount() + disappearingViewsManager.getDeletingItemsOnScreenCount();
}
/**
* {@inheritDoc}
*/
@Override
public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
spy.onLayoutChildren(recycler, state);
Log.d(TAG, "onLayoutChildren. State =" + state);
//We have nothing to show for an empty data set but clear any existing views
if (getItemCount() == 0) {
detachAndScrapAttachedViews(recycler);
return;
}
Log.i("onLayoutChildren", "isPreLayout = " + state.isPreLayout(), LogSwitcherFactory.PREDICTIVE_ANIMATIONS);
if (isLayoutRTL() != isLayoutRTL) {
//if layout direction changed programmatically we should clear anchors
isLayoutRTL = isLayoutRTL();
//so detach all views before we start searching for anchor view
detachAndScrapAttachedViews(recycler);
}
calcRecyclerCacheSize(recycler);
if (state.isPreLayout()) {
//inside pre-layout stage. It is called when item animation reconstruction will be played
//it is NOT called on layoutOrientation changes
int additionalLength = disappearingViewsManager.calcDisappearingViewsLength(recycler);
Log.d("LayoutManager", "height =" + getHeight(), LogSwitcherFactory.PREDICTIVE_ANIMATIONS);
Log.d("onDeletingHeightCalc", "additional height = " + additionalLength, LogSwitcherFactory.PREDICTIVE_ANIMATIONS);
anchorView = anchorFactory.getAnchor();
anchorFactory.resetRowCoordinates(anchorView);
Log.w(TAG, "anchor state in pre-layout = " + anchorView);
detachAndScrapAttachedViews(recycler);
//in case removing draw additional rows to show predictive animations for appearing views
AbstractCriteriaFactory criteriaFactory = stateFactory.createDefaultFinishingCriteriaFactory();
criteriaFactory.setAdditionalRowsCount(APPROXIMATE_ADDITIONAL_ROWS_COUNT);
criteriaFactory.setAdditionalLength(additionalLength);
LayouterFactory layouterFactory = stateFactory.createLayouterFactory(criteriaFactory, placerFactory.createRealPlacerFactory());
logger.onBeforeLayouter(anchorView);
fill(recycler,
layouterFactory.getBackwardLayouter(anchorView),
layouterFactory.getForwardLayouter(anchorView));
isAfterPreLayout = true;
} else {
detachAndScrapAttachedViews(recycler);
//we perform layouting stage from scratch, so cache will be rebuilt soon, we could purge it and avoid unnecessary normalization
viewPositionsStorage.purgeCacheFromPosition(anchorView.getPosition());
if (cacheNormalizationPosition != null && anchorView.getPosition() <= cacheNormalizationPosition) {
cacheNormalizationPosition = null;
}
/* In case some moving views
* we should place it at layout to support predictive animations
* we can't place all possible moves on theirs real place, because concrete layout position of particular view depends on placing of previous views
* and there could be moving from 0 position to 10k. But it is preferably to place nearest moved view to real positions to make moving more natural
* like moving from 0 position to 15 for example, where user could scroll fast and check
* so we fill additional rows to cover nearest moves
*/
AbstractCriteriaFactory criteriaFactory = stateFactory.createDefaultFinishingCriteriaFactory();
criteriaFactory.setAdditionalRowsCount(APPROXIMATE_ADDITIONAL_ROWS_COUNT);
LayouterFactory layouterFactory = stateFactory.createLayouterFactory(criteriaFactory, placerFactory.createRealPlacerFactory());
ILayouter backwardLayouter = layouterFactory.getBackwardLayouter(anchorView);
ILayouter forwardLayouter = layouterFactory.getForwardLayouter(anchorView);
fill(recycler, backwardLayouter, forwardLayouter);
/* should be executed before {@link #layoutDisappearingViews} */
if (scrollingController.normalizeGaps(recycler, null)) {
Log.d(TAG, "normalize gaps");
//we should re-layout with new anchor after normalizing gaps
anchorView = anchorFactory.getAnchor();
requestLayoutWithAnimations();
}
if (isAfterPreLayout) {
//we should layout disappearing views after pre-layout to support natural movements)
layoutDisappearingViews(recycler, backwardLayouter, forwardLayouter);
}
isAfterPreLayout = false;
}
disappearingViewsManager.reset();
if (!state.isMeasuring()) {
measureSupporter.onSizeChanged();
}
}
@Override
public void detachAndScrapAttachedViews(RecyclerView.Recycler recycler) {
super.detachAndScrapAttachedViews(recycler);
childViewPositions.clear();
}
/** layout disappearing view to support predictive animations */
private void layoutDisappearingViews(RecyclerView.Recycler recycler, @NonNull ILayouter upLayouter, ILayouter downLayouter) {
ICriteriaFactory criteriaFactory = new InfiniteCriteriaFactory();
LayouterFactory layouterFactory = stateFactory.createLayouterFactory(criteriaFactory, placerFactory.createDisappearingPlacerFactory());
DisappearingViewsManager.DisappearingViewsContainer disappearingViews = disappearingViewsManager.getDisappearingViews(recycler);
if (disappearingViews.size() > 0) {
Log.d("disappearing views", "count = " + disappearingViews.size());
Log.d("fill disappearing views", "");
downLayouter = layouterFactory.buildForwardLayouter(downLayouter);
//we should layout disappearing views left somewhere, just continue layout them in current layouter
for (int i = 0; i< disappearingViews.getForwardViews().size(); i++) {
int position = disappearingViews.getForwardViews().keyAt(i);
downLayouter.placeView(recycler.getViewForPosition(position));
}
//layout last row
downLayouter.layoutRow();
upLayouter = layouterFactory.buildBackwardLayouter(upLayouter);
//we should layout disappearing views left somewhere, just continue layout them in current layouter
for (int i = 0; i< disappearingViews.getBackwardViews().size(); i++) {
int position = disappearingViews.getBackwardViews().keyAt(i);
upLayouter.placeView(recycler.getViewForPosition(position));
}
//layout last row
upLayouter.layoutRow();
}
}
/**
* place all added views to cache (in case scrolling)...
*/
private void fillCache() {
for (int i = 0, cnt = getChildCount(); i < cnt; i++) {
View view = getChildAt(i);
int pos = getPosition(view);
viewCache.put(pos, view);
}
}
/**
* place all views on theirs right places according to current state
*/
private void fill(RecyclerView.Recycler recycler, ILayouter backwardLayouter, ILayouter forwardLayouter) {
int startingPos = anchorView.getPosition();
fillCache();
//... and remove from layout
for (int i = 0; i < viewCache.size(); i++) {
detachView(viewCache.valueAt(i));
}
logger.onStartLayouter(startingPos - 1);
/* there is no sense to perform backward layouting when anchor is null.
null anchor means that layout will be performed from absolutely top corner with start at anchor position
*/
if (anchorView.getAnchorViewRect() != null) {
//up layouter should be invoked earlier than down layouter, because views with lower positions positioned above anchorView
//start from anchor position
fillWithLayouter(recycler, backwardLayouter, startingPos - 1);
}
logger.onStartLayouter(startingPos);
//start from anchor position
fillWithLayouter(recycler, forwardLayouter, startingPos);
logger.onAfterLayouter();
//move to trash everything, which haven't used in this layout cycle
//that views gone from a screen or was removed outside from adapter
for (int i = 0; i < viewCache.size(); i++) {
removeAndRecycleView(viewCache.valueAt(i), recycler);
logger.onRemovedAndRecycled(i);
}
canvas.findBorderViews();
buildChildWithPositionsMap();
viewCache.clear();
logger.onAfterRemovingViews();
}
private void buildChildWithPositionsMap() {
childViewPositions.clear();
for (View view : childViews) {
int position = getPosition(view);
childViewPositions.put(position, view);
}
}
/**
* place views in layout started from chosen position with chosen layouter
*/
private void fillWithLayouter(RecyclerView.Recycler recycler, ILayouter layouter, int startingPos) {
if (startingPos < 0) return;
AbstractPositionIterator iterator = layouter.positionIterator();
iterator.move(startingPos);
while (iterator.hasNext()) {
int pos = iterator.next();
View view = viewCache.get(pos);
if (view == null) { // we don't have view from previous layouter stage, request new one
try {
view = recycler.getViewForPosition(pos);
} catch (IndexOutOfBoundsException e) {
/* WTF sometimes on prediction animation playing in case very fast sequential changes in adapter
* {@link #getItemCount} could return value bigger than real count of items
* & {@link RecyclerView.Recycler#getViewForPosition(int)} throws exception in this case!
* to handle it, just leave the loop*/
break;
}
logger.onItemRequested();
if (!layouter.placeView(view)) {
/* reached end of visible bounds, exit.
recycle view, which was requested previously
*/
recycler.recycleView(view);
logger.onItemRecycled();
break;
}
} else { //we have detached views from previous layouter stage, attach it if needed
if (!layouter.onAttachView(view)) {
break;
}
//remove reattached view from cache
viewCache.remove(pos);
}
}
logger.onFinishedLayouter();
//layout last row, in case iterator fully processed
layouter.layoutRow();
}
/**
* recycler should contain all recycled views from a longest row, not just 2 holders by default
*/
private void calcRecyclerCacheSize(RecyclerView.Recycler recycler) {
int viewsInRow = maxViewsInRow == null ? INT_ROW_SIZE_APPROXIMATELY_FOR_CACHE : maxViewsInRow;
recycler.setViewCacheSize((int) (viewsInRow * FAST_SCROLLING_COEFFICIENT));
}
/**
* after several layout changes our item views probably haven't placed on right places,
* because we don't memorize whole positions of items.
* So them should be normalized to real positions when we can do it.
*/
private void performNormalizationIfNeeded() {
if (cacheNormalizationPosition != null && getChildCount() > 0) {
final View firstView = getChildAt(0);
int firstViewPosition = getPosition(firstView);
if (firstViewPosition < cacheNormalizationPosition ||
(cacheNormalizationPosition == 0 && cacheNormalizationPosition == firstViewPosition)) {
//perform normalization when we have reached previous position then normalization position
Log.d("normalization", "position = " + cacheNormalizationPosition + " top view position = " + firstViewPosition);
Log.d(TAG, "cache purged from position " + firstViewPosition);
viewPositionsStorage.purgeCacheFromPosition(firstViewPosition);
//reset normalization position
cacheNormalizationPosition = null;
requestLayoutWithAnimations();
}
}
}
///////////////////////////////////////////////////////////////////////////
// measure
///////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
@Override
public void setMeasuredDimension(int widthSize, int heightSize) {
measureSupporter.measure(widthSize, heightSize);
Log.i(TAG, "measured dimension = " + heightSize);
super.setMeasuredDimension(measureSupporter.getMeasuredWidth(), measureSupporter.getMeasuredHeight());
}
///////////////////////////////////////////////////////////////////////////
// data set changed events
///////////////////////////////////////////////////////////////////////////
/**
* {@inheritDoc}
*/
@Override
public void onAdapterChanged(RecyclerView.Adapter oldAdapter,
RecyclerView.Adapter newAdapter) {
if (oldAdapter != null && measureSupporter.isRegistered()) {
try {
measureSupporter.setRegistered(false);
oldAdapter.unregisterAdapterDataObserver((RecyclerView.AdapterDataObserver) measureSupporter);
} catch (IllegalStateException e) {
//skip unregister errors
}
}
if (newAdapter != null) {
measureSupporter.setRegistered(true);
newAdapter.registerAdapterDataObserver((RecyclerView.AdapterDataObserver) measureSupporter);
}
//Completely scrap the existing layout
removeAllViews();
}
/**
* {@inheritDoc}
*/
@Override
public void onItemsRemoved(final RecyclerView recyclerView, int positionStart, int itemCount) {
Log.d("onItemsRemoved", "starts from = " + positionStart + ", item count = " + itemCount, LogSwitcherFactory.ADAPTER_ACTIONS);
super.onItemsRemoved(recyclerView, positionStart, itemCount);
onLayoutUpdatedFromPosition(positionStart);
measureSupporter.onItemsRemoved(recyclerView);
}
/**
* {@inheritDoc}
*/
@Override
public void onItemsAdded(RecyclerView recyclerView, int positionStart, int itemCount) {
Log.d("onItemsAdded", "starts from = " + positionStart + ", item count = " + itemCount, LogSwitcherFactory.ADAPTER_ACTIONS);
super.onItemsAdded(recyclerView, positionStart, itemCount);
onLayoutUpdatedFromPosition(positionStart);
}
/**
* {@inheritDoc}
*/
@Override
public void onItemsChanged(RecyclerView recyclerView) {
Log.d("onItemsChanged", "", LogSwitcherFactory.ADAPTER_ACTIONS);
super.onItemsChanged(recyclerView);
viewPositionsStorage.purge();
onLayoutUpdatedFromPosition(0);
}
/**
* {@inheritDoc}
*/
@Override
public void onItemsUpdated(RecyclerView recyclerView, int positionStart, int itemCount) {
Log.d("onItemsUpdated", "starts from = " + positionStart + ", item count = " + itemCount, LogSwitcherFactory.ADAPTER_ACTIONS);
super.onItemsUpdated(recyclerView, positionStart, itemCount);
onLayoutUpdatedFromPosition(positionStart);
}
/**
* {@inheritDoc}
*/
@Override
public void onItemsUpdated(RecyclerView recyclerView, int positionStart, int itemCount, Object payload) {
onItemsUpdated(recyclerView, positionStart, itemCount);
}
/**
* {@inheritDoc}
*/
@Override
public void onItemsMoved(RecyclerView recyclerView, int from, int to, int itemCount) {
Log.d("onItemsMoved", String.format(Locale.US, "from = %d, to = %d, itemCount = %d", from, to, itemCount), LogSwitcherFactory.ADAPTER_ACTIONS);
super.onItemsMoved(recyclerView, from, to, itemCount);
onLayoutUpdatedFromPosition(Math.min(from, to));
}
/** update cache according to data changes */
private void onLayoutUpdatedFromPosition(int position) {
Log.d(TAG, "cache purged from position " + position);
viewPositionsStorage.purgeCacheFromPosition(position);
int startRowPos = viewPositionsStorage.getStartOfRow(position);
cacheNormalizationPosition = cacheNormalizationPosition == null ?
startRowPos : Math.min(cacheNormalizationPosition, startRowPos);
}
///////////////////////////////////////////////////////////////////////////
// Scrolling
///////////////////////////////////////////////////////////////////////////
/**
* 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).
*
* Also this is {@link ChipsLayoutManager} specific issue, that we can't predict exact count of items on screen
* in general case, because we can't predict items count in row.
* So to enable it you should accomplish one of those conditions:
* <ul>
* <li> Your items have same width and height </li>
* <li> You have {@link ChipsLayoutManager#setMaxViewsInRow(Integer)} set and you able to make sure, that there won't be many rows with lower items count.
* The best is none. </li>
* </ul>
*
* 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 adapter and the position of the visible items inside
* the adapter. This provides a stable scrollbar as the user navigates through a list of items
* with varying widths / heights.
*
* @param enabled Whether or not to enable smooth scrollbar.
*
* @see #isSmoothScrollbarEnabled()
*/
@Override
public void setSmoothScrollbarEnabled(boolean enabled) {
isSmoothScrollbarEnabled = enabled;
}
/**
* Returns the current state of the smooth scrollbar feature. It is NOT enabled by default.
*
* @return True if smooth scrollbar is enabled, false otherwise.
*
* @see #setSmoothScrollbarEnabled(boolean)
*/
@Override
public boolean isSmoothScrollbarEnabled() {
return isSmoothScrollbarEnabled;
}
/**
* {@inheritDoc}
*/
public void scrollToPosition(int position) {
if (position >= getItemCount() || position < 0) {
Log.e("span layout manager", "Cannot scroll to " + position + ", item count " + getItemCount());
return;
}
Integer lastCachePosition = viewPositionsStorage.getLastCachePosition();
cacheNormalizationPosition = cacheNormalizationPosition != null ? cacheNormalizationPosition : lastCachePosition;
if (lastCachePosition != null && position < lastCachePosition) {
position = viewPositionsStorage.getStartOfRow(position);
}
anchorView = anchorFactory.createNotFound();
anchorView.setPosition(position);
//Trigger a new view layout
super.requestLayout();
}
/**
* {@inheritDoc}
*/
@Override
public void smoothScrollToPosition(RecyclerView recyclerView, RecyclerView.State state, final int position) {
if (position >= getItemCount() || position < 0) {
Log.e("span layout manager", "Cannot scroll to " + position + ", item count " + getItemCount());
return;
}
RecyclerView.SmoothScroller scroller = scrollingController.createSmoothScroller(recyclerView.getContext(), position, 150, anchorView);
scroller.setTargetPosition(position);
startSmoothScroll(scroller);
}
@Override
public boolean canScrollHorizontally() {
return scrollingController.canScrollHorizontally();
}
@Override
public boolean canScrollVertically() {
return scrollingController.canScrollVertically();
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int scrollVerticallyBy(int dy, RecyclerView.Recycler recycler, RecyclerView.State state) {
return scrollingController.scrollVerticallyBy(dy, recycler, state);
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int scrollHorizontallyBy(int dx, RecyclerView.Recycler recycler, RecyclerView.State state) {
return scrollingController.scrollHorizontallyBy(dx, recycler, state);
}
public VerticalScrollingController verticalScrollingController() {
return new VerticalScrollingController(this, stateFactory, this);
}
public HorizontalScrollingController horizontalScrollingController() {
return new HorizontalScrollingController(this, stateFactory, this);
}
@Override
public void onScrolled(IScrollingController scrollingController, RecyclerView.Recycler recycler, RecyclerView.State state) {
performNormalizationIfNeeded();
anchorView = anchorFactory.getAnchor();
AbstractCriteriaFactory criteriaFactory = stateFactory.createDefaultFinishingCriteriaFactory();
criteriaFactory.setAdditionalRowsCount(1);
LayouterFactory factory = stateFactory.createLayouterFactory(criteriaFactory, placerFactory.createRealPlacerFactory());
fill(recycler,
factory.getBackwardLayouter(anchorView),
factory.getForwardLayouter(anchorView));
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int computeVerticalScrollOffset(RecyclerView.State state) {
return scrollingController.computeVerticalScrollOffset(state);
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int computeVerticalScrollExtent(RecyclerView.State state) {
return scrollingController.computeVerticalScrollExtent(state);
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int computeVerticalScrollRange(RecyclerView.State state) {
return scrollingController.computeVerticalScrollRange(state);
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int computeHorizontalScrollExtent(RecyclerView.State state) {
return scrollingController.computeHorizontalScrollExtent(state);
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int computeHorizontalScrollOffset(RecyclerView.State state) {
return scrollingController.computeHorizontalScrollOffset(state);
}
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Override
public int computeHorizontalScrollRange(RecyclerView.State state) {
return scrollingController.computeHorizontalScrollRange(state);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/ChipsLayoutManager.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 9,331 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.CallSuper;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.Pair;
import android.view.View;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.IBorder;
import com.beloo.widget.chipslayoutmanager.SpanLayoutChildGravity;
import com.beloo.widget.chipslayoutmanager.gravity.IGravityModifiersFactory;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategy;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.ILayoutRowBreaker;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.gravity.IChildGravityResolver;
import com.beloo.widget.chipslayoutmanager.gravity.IGravityModifier;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.IFinishingCriteria;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacer;
import com.beloo.widget.chipslayoutmanager.util.AssertionUtils;
/** this class performs measuring, calculation, and placing of views on border (layout manager) according to state criterias */
public abstract class AbstractLayouter implements ILayouter, IBorder {
private int currentViewWidth;
private int currentViewHeight;
private int currentViewPosition;
List<Pair<Rect, View>> rowViews = new LinkedList<>();
/** bottom of current row*/
int viewBottom;
/** top of current row*/
int viewTop;
/** right offset */
int viewRight;
/** left offset*/
int viewLeft;
private int rowSize = 0;
private int previousRowSize;
/** is row completed when {@link #layoutRow()} called*/
private boolean isRowCompleted;
///////////////////////////////////////////////////////////////////////////
// input dependencies
///////////////////////////////////////////////////////////////////////////
@NonNull
private ChipsLayoutManager layoutManager;
@NonNull
private IViewCacheStorage cacheStorage;
@NonNull
private IBorder border;
@NonNull
private IChildGravityResolver childGravityResolver;
@NonNull
private IFinishingCriteria finishingCriteria;
@NonNull
private IPlacer placer;
@NonNull
private ILayoutRowBreaker breaker;
@NonNull
private IRowStrategy rowStrategy;
private Set<ILayouterListener> layouterListeners = new HashSet<>();
@NonNull
private IGravityModifiersFactory gravityModifiersFactory;
@NonNull
private AbstractPositionIterator positionIterator;
//--- end input dependencies
AbstractLayouter(Builder builder) {
//--- read builder
layoutManager = builder.layoutManager;
cacheStorage = builder.cacheStorage;
border = builder.border;
childGravityResolver = builder.childGravityResolver;
this.finishingCriteria = builder.finishingCriteria;
placer = builder.placer;
this.viewTop = builder.offsetRect.top;
this.viewBottom = builder.offsetRect.bottom;
this.viewRight = builder.offsetRect.right;
this.viewLeft = builder.offsetRect.left;
this.layouterListeners = builder.layouterListeners;
this.breaker = builder.breaker;
this.gravityModifiersFactory = builder.gravityModifiersFactory;
this.rowStrategy = builder.rowStrategy;
this.positionIterator = builder.positionIterator;
//--- end read builder
}
void setFinishingCriteria(@NonNull IFinishingCriteria finishingCriteria) {
this.finishingCriteria = finishingCriteria;
}
@Override
public AbstractPositionIterator positionIterator() {
return positionIterator;
}
public boolean isRowCompleted() {
return isRowCompleted;
}
public List<Item> getCurrentRowItems() {
List<Item> items = new LinkedList<>();
List<Pair<Rect, View>> mutableRowViews = new LinkedList<>(rowViews);
if (isReverseOrder()) {
Collections.reverse(mutableRowViews);
}
for (Pair<Rect, View> rowView : mutableRowViews) {
items.add(new Item(rowView.first, layoutManager.getPosition(rowView.second)));
}
return items;
}
public final int getCurrentViewPosition() {
return currentViewPosition;
}
final IViewCacheStorage getCacheStorage() {
return cacheStorage;
}
public void addLayouterListener(ILayouterListener layouterListener) {
if (layouterListener != null)
layouterListeners.add(layouterListener);
}
@Override
public void removeLayouterListener(ILayouterListener layouterListener) {
layouterListeners.remove(layouterListener);
}
private void notifyLayouterListeners() {
for (ILayouterListener layouterListener : layouterListeners) {
layouterListener.onLayoutRow(this);
}
}
@Override
public final int getPreviousRowSize() {
return previousRowSize;
}
/** read view params to memory */
private void calculateView(View view) {
currentViewHeight = layoutManager.getDecoratedMeasuredHeight(view);
currentViewWidth = layoutManager.getDecoratedMeasuredWidth(view);
currentViewPosition = layoutManager.getPosition(view);
}
@Override
@CallSuper
/** calculate view positions, view won't be actually added to layout when calling this method
* @return true if view successfully placed, false if view can't be placed because out of space on screen and have to be recycled */
public final boolean placeView(View view) {
layoutManager.measureChildWithMargins(view, 0, 0);
calculateView(view);
if (canNotBePlacedInCurrentRow()) {
isRowCompleted = true;
layoutRow();
}
if (isFinishedLayouting()) return false;
rowSize++;
Rect rect = createViewRect(view);
rowViews.add(new Pair<>(rect, view));
return true;
}
/** if all necessary view have placed*/
public final boolean isFinishedLayouting() {
return finishingCriteria.isFinishedLayouting(this);
}
/** check if we can not add current view to row
* we determine it on the next layouter step, because we need next view size to determine whether it fits in row or not */
@SuppressWarnings("WeakerAccess")
public final boolean canNotBePlacedInCurrentRow() {
return breaker.isRowBroke(this);
}
/** factory method for Rect, where view will be placed. Creation based on inner layouter parameters */
abstract Rect createViewRect(View view);
/** check whether items in {@link #rowViews} are in reverse order. It is true for backward layouters */
abstract boolean isReverseOrder();
/** called when layouter ready to add row to border. Children could perform normalization actions on created row*/
abstract void onPreLayout();
/** called after row have been layouted. Children should prepare new row here. */
abstract void onAfterLayout();
abstract boolean isAttachedViewFromNewRow(View view);
abstract void onInterceptAttachView(View view);
void setPlacer(@NonNull IPlacer placer) {
this.placer = placer;
}
@CallSuper
@Override
/** Read layouter state from current attached view. We need only last of it, but we can't determine here which is last.
* Based on characteristics of last attached view, layouter algorithm will be able to continue placing from it.
* This method have to be called on attaching view*/
public final boolean onAttachView(View view) {
calculateView(view);
if (isAttachedViewFromNewRow(view)) {
//new row, reset row size
notifyLayouterListeners();
rowSize = 0;
}
onInterceptAttachView(view);
if (isFinishedLayouting()) return false;
rowSize++;
layoutManager.attachView(view);
return true;
}
@Override
/** add views from current row to layout*/
public final void layoutRow() {
onPreLayout();
//apply modifiers to whole row
if (rowViews.size() > 0) {
rowStrategy.applyStrategy(this, getCurrentRowItems());
}
/** layout pre-calculated row on a recyclerView border */
for (Pair<Rect, View> rowViewRectPair : rowViews) {
Rect viewRect = rowViewRectPair.first;
View view = rowViewRectPair.second;
viewRect = applyChildGravity(view, viewRect);
//add view to layout
placer.addView(view);
//layout whole views in a row
layoutManager.layoutDecorated(view, viewRect.left, viewRect.top, viewRect.right, viewRect.bottom);
}
onAfterLayout();
notifyLayouterListeners();
previousRowSize = rowSize;
//clear row data
this.rowSize = 0;
rowViews.clear();
isRowCompleted = false;
}
/** by default items placed and attached to a top of the row.
* Modify theirs relative positions according to the selected child gravity
* @return modified rect with applied gravity */
private Rect applyChildGravity(View view, Rect viewRect) {
@SpanLayoutChildGravity
int viewGravity = childGravityResolver.getItemGravity(getLayoutManager().getPosition(view));
IGravityModifier gravityModifier = gravityModifiersFactory.getGravityModifier(viewGravity);
return gravityModifier.modifyChildRect(getStartRowBorder(), getEndRowBorder(), viewRect);
}
@NonNull
public ChipsLayoutManager getLayoutManager() {
return layoutManager;
}
/** get count of items inside current row */
@Override
public int getRowSize() {
return rowSize;
}
public int getViewTop() {
return viewTop;
}
/** get a start coordinate of row border which is perpendicular to row general extension*/
public abstract int getStartRowBorder();
/** get an end coordinate of row border which is perpendicular to row general extension*/
public abstract int getEndRowBorder();
@Override
public Rect getRowRect() {
return new Rect(getCanvasLeftBorder(), getViewTop(), getCanvasRightBorder(), getViewBottom());
}
public int getViewBottom() {
return viewBottom;
}
final Rect getOffsetRect() {
return new Rect(viewLeft, viewTop, viewRight, viewBottom);
}
public final int getViewLeft() {
return viewLeft;
}
public final int getViewRight() {
return viewRight;
}
public final int getCurrentViewWidth() {
return currentViewWidth;
}
public final int getCurrentViewHeight() {
return currentViewHeight;
}
public abstract int getRowLength();
public abstract static class Builder {
private ChipsLayoutManager layoutManager;
private IViewCacheStorage cacheStorage;
private IBorder border;
private IChildGravityResolver childGravityResolver;
private IFinishingCriteria finishingCriteria;
private IPlacer placer;
private ILayoutRowBreaker breaker;
private Rect offsetRect;
private HashSet<ILayouterListener> layouterListeners = new HashSet<>();
private IGravityModifiersFactory gravityModifiersFactory;
private IRowStrategy rowStrategy;
private AbstractPositionIterator positionIterator;
Builder() {}
@SuppressWarnings("WeakerAccess")
@NonNull
public Builder offsetRect(@NonNull Rect offsetRect) {
this.offsetRect = offsetRect;
return this;
}
@NonNull
public final Builder layoutManager(@NonNull ChipsLayoutManager layoutManager) {
this.layoutManager = layoutManager;
return this;
}
@NonNull
final Builder cacheStorage(@NonNull IViewCacheStorage cacheStorage) {
this.cacheStorage = cacheStorage;
return this;
}
@NonNull
Builder rowStrategy(IRowStrategy rowStrategy) {
this.rowStrategy = rowStrategy;
return this;
}
@NonNull
final Builder canvas(@NonNull IBorder border) {
this.border = border;
return this;
}
@NonNull
final Builder gravityModifiersFactory(@NonNull IGravityModifiersFactory gravityModifiersFactory) {
this.gravityModifiersFactory = gravityModifiersFactory;
return this;
}
@NonNull
final Builder childGravityResolver(@NonNull IChildGravityResolver childGravityResolver) {
this.childGravityResolver = childGravityResolver;
return this;
}
@NonNull
final Builder finishingCriteria(@NonNull IFinishingCriteria finishingCriteria) {
this.finishingCriteria = finishingCriteria;
return this;
}
@NonNull
public final Builder placer(@NonNull IPlacer placer) {
this.placer = placer;
return this;
}
@SuppressWarnings("unused")
@NonNull
final Builder addLayouterListener(@Nullable ILayouterListener layouterListener) {
if (layouterListener != null) {
layouterListeners.add(layouterListener);
}
return this;
}
@NonNull
final Builder breaker(@NonNull ILayoutRowBreaker breaker) {
AssertionUtils.assertNotNull(breaker, "breaker shouldn't be null");
this.breaker = breaker;
return this;
}
@NonNull
final Builder addLayouterListeners(@NonNull List<ILayouterListener> layouterListeners) {
this.layouterListeners.addAll(layouterListeners);
return this;
}
@NonNull
public Builder positionIterator(AbstractPositionIterator positionIterator) {
this.positionIterator = positionIterator;
return this;
}
@NonNull
protected abstract AbstractLayouter createLayouter();
public final AbstractLayouter build() {
if (layoutManager == null)
throw new IllegalStateException("layoutManager can't be null, call #layoutManager()");
if (breaker == null)
throw new IllegalStateException("breaker can't be null, call #breaker()");
if (border == null)
throw new IllegalStateException("border can't be null, call #border()");
if (cacheStorage == null)
throw new IllegalStateException("cacheStorage can't be null, call #cacheStorage()");
if (rowStrategy == null)
throw new IllegalStateException("rowStrategy can't be null, call #rowStrategy()");
if (offsetRect == null)
throw new IllegalStateException("offsetRect can't be null, call #offsetRect()");
if (finishingCriteria == null)
throw new IllegalStateException("finishingCriteria can't be null, call #finishingCriteria()");
if (placer == null)
throw new IllegalStateException("placer can't be null, call #placer()");
if (gravityModifiersFactory == null)
throw new IllegalStateException("gravityModifiersFactory can't be null, call #gravityModifiersFactory()");
if (childGravityResolver == null)
throw new IllegalStateException("childGravityResolver can't be null, call #childGravityResolver()");
if (positionIterator == null)
throw new IllegalStateException("positionIterator can't be null, call #positionIterator()");
return createLayouter();
}
}
///////////////////////////////////////////////////////////////////////////
// border delegate
///////////////////////////////////////////////////////////////////////////
public final int getCanvasRightBorder() {
return border.getCanvasRightBorder();
}
public final int getCanvasBottomBorder() {
return border.getCanvasBottomBorder();
}
public final int getCanvasLeftBorder() {
return border.getCanvasLeftBorder();
}
public final int getCanvasTopBorder() {
return border.getCanvasTopBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/AbstractLayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 3,260 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.view.View;
class LTRDownLayouter extends AbstractLayouter {
private boolean isPurged;
private LTRDownLayouter(Builder builder) {
super(builder);
}
public static Builder newBuilder() {
return new Builder();
}
@Override
Rect createViewRect(View view) {
Rect viewRect = new Rect(viewLeft, viewTop, viewLeft + getCurrentViewWidth(), viewTop + getCurrentViewHeight());
viewLeft = viewRect.right;
viewBottom = Math.max(viewBottom, viewRect.bottom);
return viewRect;
}
@Override
boolean isReverseOrder() {
return false;
}
@Override
void onPreLayout() {
if (!rowViews.isEmpty()) {
//todo this isn't great place for that. Should be refactored somehow
if (!isPurged) {
isPurged = true;
getCacheStorage().purgeCacheFromPosition(getLayoutManager().getPosition(rowViews.get(0).second));
}
//cache only when go down
getCacheStorage().storeRow(rowViews);
}
}
@Override
void onAfterLayout() {
//go to next row, increase top coordinate, reset left
viewLeft = getCanvasLeftBorder();
viewTop = viewBottom;
}
@Override
boolean isAttachedViewFromNewRow(View view) {
int topOfCurrentView = getLayoutManager().getDecoratedTop(view);
int leftOfCurrentView = getLayoutManager().getDecoratedLeft(view);
return viewBottom <= topOfCurrentView
&& leftOfCurrentView < viewLeft;
}
@Override
public void onInterceptAttachView(View view) {
viewTop = getLayoutManager().getDecoratedTop(view);
viewLeft = getLayoutManager().getDecoratedRight(view);
viewBottom = Math.max(viewBottom, getLayoutManager().getDecoratedBottom(view));
}
@Override
public int getStartRowBorder() {
return getViewTop();
}
@Override
public int getEndRowBorder() {
return getViewBottom();
}
@Override
public int getRowLength() {
return viewLeft - getCanvasLeftBorder();
}
public static final class Builder extends AbstractLayouter.Builder {
private Builder() {
}
@NonNull
public LTRDownLayouter createLayouter() {
return new LTRDownLayouter(this);
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/LTRDownLayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 555 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.annotation.IntRange;
class DecrementalPositionIterator extends AbstractPositionIterator {
DecrementalPositionIterator(@IntRange(from = 0) int itemCount) {
super(itemCount);
}
@Override
public boolean hasNext() {
return pos >= 0;
}
@Override
public Integer next() {
if (!hasNext()) throw new IllegalStateException("position out of bounds reached");
return pos--;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/DecrementalPositionIterator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 108 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.IScrollingController;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.anchor.IAnchorFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.AbstractCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
public interface IStateFactory {
@SuppressWarnings("UnnecessaryLocalVariable")
LayouterFactory createLayouterFactory(ICriteriaFactory criteriaFactory, IPlacerFactory placerFactory);
AbstractCriteriaFactory createDefaultFinishingCriteriaFactory();
IAnchorFactory anchorFactory();
IScrollingController scrollingController();
ICanvas createCanvas();
int getSizeMode();
int getStart();
int getStart(View view);
int getStart(AnchorViewState anchor);
int getStartAfterPadding();
int getStartViewPosition();
int getStartViewBound();
int getEnd();
int getEnd(View view);
int getEndAfterPadding();
int getEnd(AnchorViewState anchor);
int getEndViewPosition();
int getEndViewBound();
int getTotalSpace();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/IStateFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 272 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.ChildViewsIterable;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
abstract class Square implements ICanvas {
RecyclerView.LayoutManager lm;
private ChildViewsIterable childViews;
/**
* highest view in layout. Have always actual value, because it set in {@link ChipsLayoutManager#onLayoutChildren}
*/
private View topView;
/**
* lowest view in layout. Have always actual value, because it set in {@link ChipsLayoutManager#onLayoutChildren}
*/
private View bottomView;
/**
* The view have placed in the closest to the left border. Have always actual value, because it set in {@link ChipsLayoutManager#onLayoutChildren}
*/
private View leftView;
/** The view have placed in the closest to the right border. Have always actual value, because it set in {@link ChipsLayoutManager#onLayoutChildren} */
private View rightView;
/** minimal position visible on screen*/
private Integer minPositionOnScreen;
private Integer maxPositionOnScreen;
private boolean isFirstItemAdded;
Square(RecyclerView.LayoutManager lm) {
this.lm = lm;
childViews = new ChildViewsIterable(lm);
}
@Override
public Rect getCanvasRect() {
return new Rect(getCanvasLeftBorder(), getCanvasTopBorder(), getCanvasRightBorder(), getCanvasBottomBorder());
}
@Override
public Rect getViewRect(View view) {
int left = lm.getDecoratedLeft(view);
int top = lm.getDecoratedTop(view);
int right = lm.getDecoratedRight(view);
int bottom = lm.getDecoratedBottom(view);
return new Rect(left, top, right, bottom);
}
@Override
public boolean isInside(Rect rectCandidate) {
//intersection changes rect!!!
Rect intersect = new Rect(rectCandidate);
return getCanvasRect().intersect(intersect);
}
@Override
public boolean isInside(View viewCandidate) {
return isInside(getViewRect(viewCandidate));
}
@Override
public boolean isFullyVisible(View view) {
Rect rect = getViewRect(view);
return isFullyVisible(rect);
}
@Override
public boolean isFullyVisible(Rect rect) {
return rect.top >= getCanvasTopBorder()
&& rect.bottom <= getCanvasBottomBorder()
&& rect.left >= getCanvasLeftBorder()
&& rect.right <= getCanvasRightBorder();
}
/**
* find highest & lowest views among visible attached views
*/
@Override
public void findBorderViews() {
topView = null;
bottomView = null;
leftView = null;
rightView = null;
minPositionOnScreen = RecyclerView.NO_POSITION;
maxPositionOnScreen = RecyclerView.NO_POSITION;
isFirstItemAdded = false;
if (lm.getChildCount() > 0) {
View initView = lm.getChildAt(0);
topView = initView;
bottomView = initView;
leftView = initView;
rightView = initView;
for (View view : childViews) {
int position = lm.getPosition(view);
if (!isInside(view)) continue;
if (lm.getDecoratedTop(view) < lm.getDecoratedTop(topView)) {
topView = view;
}
if (lm.getDecoratedBottom(view) > lm.getDecoratedBottom(bottomView)) {
bottomView = view;
}
if (lm.getDecoratedLeft(view) < lm.getDecoratedLeft(leftView)) {
leftView = view;
}
if (lm.getDecoratedRight(view) > lm.getDecoratedRight(rightView)) {
rightView = view;
}
if (minPositionOnScreen == RecyclerView.NO_POSITION || position < minPositionOnScreen) {
minPositionOnScreen = position;
}
if (maxPositionOnScreen == RecyclerView.NO_POSITION || position > maxPositionOnScreen) {
maxPositionOnScreen = position;
}
if (position == 0) {
isFirstItemAdded = true;
}
}
}
}
@Override
public View getTopView() {
return topView;
}
@Override
public View getBottomView() {
return bottomView;
}
@Override
public View getLeftView() {
return leftView;
}
@Override
public View getRightView() {
return rightView;
}
@Override
public Integer getMinPositionOnScreen() {
return minPositionOnScreen;
}
@Override
public Integer getMaxPositionOnScreen() {
return maxPositionOnScreen;
}
@Override
public boolean isFirstItemAdded() {
return isFirstItemAdded;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/Square.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 1,041 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.util.Pair;
import android.view.View;
import java.util.Collections;
class RTLUpLayouter extends AbstractLayouter implements ILayouter {
private static final String TAG = RTLUpLayouter.class.getSimpleName();
private RTLUpLayouter(Builder builder) {
super(builder);
}
public static Builder newBuilder() {
return new Builder();
}
@Override
void onPreLayout() {
int leftOffsetOfRow = -(getCanvasRightBorder() - viewLeft);
viewLeft = rowViews.size() > 0 ? Integer.MAX_VALUE : 0;
for (Pair<Rect, View> rowViewRectPair : rowViews) {
Rect viewRect = rowViewRectPair.first;
viewRect.left = viewRect.left - leftOffsetOfRow;
viewRect.right = viewRect.right - leftOffsetOfRow;
viewLeft = Math.min(viewLeft, viewRect.left);
viewTop = Math.min(viewTop, viewRect.top);
viewBottom = Math.max(viewBottom, viewRect.bottom);
}
}
@Override
void onAfterLayout() {
//go to next row, increase top coordinate, reset left
viewLeft = getCanvasLeftBorder();
viewBottom = viewTop;
}
@Override
boolean isAttachedViewFromNewRow(View view) {
int bottomOfCurrentView = getLayoutManager().getDecoratedBottom(view);
int leftOfCurrentView = getLayoutManager().getDecoratedLeft(view);
return viewTop >= bottomOfCurrentView
&& leftOfCurrentView < viewLeft;
}
@Override
Rect createViewRect(View view) {
int right = viewLeft + getCurrentViewWidth();
int viewTop = viewBottom - getCurrentViewHeight();
Rect viewRect = new Rect(viewLeft, viewTop, right, viewBottom);
viewLeft = viewRect.right;
return viewRect;
}
@Override
boolean isReverseOrder() {
return true;
}
@Override
public void onInterceptAttachView(View view) {
if (viewLeft != getCanvasLeftBorder() && viewLeft + getCurrentViewWidth() > getCanvasRightBorder()) {
viewLeft = getCanvasLeftBorder();
viewBottom = viewTop;
} else {
viewLeft = getLayoutManager().getDecoratedRight(view);
}
viewTop = Math.min(viewTop, getLayoutManager().getDecoratedTop(view));
}
@Override
public int getStartRowBorder() {
return getViewTop();
}
@Override
public int getEndRowBorder() {
return getViewBottom();
}
@Override
public int getRowLength() {
return getCanvasRightBorder() - viewLeft;
}
public static final class Builder extends AbstractLayouter.Builder {
private Builder() {
}
@NonNull
public RTLUpLayouter createLayouter() {
return new RTLUpLayouter(this);
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RTLUpLayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 656 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.v7.widget.RecyclerView;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategyFactory;
import com.beloo.widget.chipslayoutmanager.gravity.RTLRowStrategyFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IBreakerFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.RTLRowBreakerFactory;
class RTLRowsOrientationStateFactory implements IOrientationStateFactory {
@Override
public ILayouterCreator createLayouterCreator(RecyclerView.LayoutManager lm) {
return new RTLRowsCreator(lm);
}
@Override
public IRowStrategyFactory createRowStrategyFactory() {
return new RTLRowStrategyFactory();
}
@Override
public IBreakerFactory createDefaultBreaker() {
return new RTLRowBreakerFactory();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RTLRowsOrientationStateFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 188 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.v7.widget.RecyclerView;
public interface IMeasureSupporter {
void onItemsRemoved(RecyclerView recyclerView);
void onSizeChanged();
void measure(int autoWidth, int autoHeight);
int getMeasuredWidth();
int getMeasuredHeight();
boolean isRegistered();
void setRegistered(boolean isRegistered);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/IMeasureSupporter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 81 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.annotation.IntRange;
import java.util.Iterator;
public abstract class AbstractPositionIterator implements Iterator<Integer> {
int pos;
int itemCount;
AbstractPositionIterator(@IntRange(from = 0) int itemCount) {
if (itemCount < 0) throw new IllegalArgumentException("item count couldn't be negative");
this.itemCount = itemCount;
}
public void move(@IntRange(from = 0) int pos) {
if (pos >= itemCount) throw new IllegalArgumentException("you can't move above of maxItemCount");
if (pos < 0) throw new IllegalArgumentException("can't move to negative position");
this.pos = pos;
}
@Override
public void remove() {
throw new UnsupportedOperationException("removing not supported in position iterator");
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/AbstractPositionIterator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 178 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.v7.widget.RecyclerView;
class RowSquare extends Square {
RowSquare(RecyclerView.LayoutManager lm) {
super(lm);
}
public final int getCanvasRightBorder() {
return lm.getWidth() - lm.getPaddingRight();
}
/** get bottom border. Controlled by clipToPadding property*/
public final int getCanvasBottomBorder() {
return lm.getHeight();
}
public final int getCanvasLeftBorder() {
return lm.getPaddingLeft();
}
/** get bottom border. Controlled by clipToPadding property*/
public final int getCanvasTopBorder() {
return 0;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RowSquare.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 147 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.v7.widget.RecyclerView;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.gravity.IGravityModifiersFactory;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategy;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IBreakerFactory;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
class LTRRowsCreator implements ILayouterCreator {
private RecyclerView.LayoutManager layoutManager;
LTRRowsCreator(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
@Override
public Rect createOffsetRectForBackwardLayouter(AnchorViewState anchor) {
Rect anchorRect = anchor.getAnchorViewRect();
return new Rect(
0,
anchorRect == null ? 0 : anchorRect.top,
//we shouldn't include anchor view here, so anchorLeft is a rightOffset
anchorRect == null ? 0 : anchorRect.left,
anchorRect == null ? 0 : anchorRect.bottom);
}
@Override
public Rect createOffsetRectForForwardLayouter(AnchorViewState anchor) {
Rect anchorRect = anchor.getAnchorViewRect();
return new Rect(
//we should include anchor view here, so anchorLeft is a leftOffset
anchorRect == null ? layoutManager.getPaddingLeft() : anchorRect.left,
anchorRect == null ? anchor.getPosition() == 0 ? layoutManager.getPaddingTop() : 0 : anchorRect.top,
0,
anchorRect == null ? anchor.getPosition() == 0 ? layoutManager.getPaddingBottom() : 0 : anchorRect.bottom);
}
@Override
public AbstractLayouter.Builder createBackwardBuilder() {
return LTRUpLayouter.newBuilder();
}
@Override
public AbstractLayouter.Builder createForwardBuilder() {
return LTRDownLayouter.newBuilder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/LTRRowsCreator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 470 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.gravity.IGravityModifiersFactory;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategy;
import com.beloo.widget.chipslayoutmanager.gravity.SkipLastRowStrategy;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IBreakerFactory;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
import java.util.ArrayList;
import java.util.List;
public class LayouterFactory {
private ChipsLayoutManager layoutManager;
private IViewCacheStorage cacheStorage;
private List<ILayouterListener> layouterListeners = new ArrayList<>();
private IBreakerFactory breakerFactory;
private ICriteriaFactory criteriaFactory;
private IPlacerFactory placerFactory;
private IGravityModifiersFactory gravityModifiersFactory;
private IRowStrategy rowStrategy;
private ILayouterCreator layouterCreator;
LayouterFactory(ChipsLayoutManager layoutManager,
ILayouterCreator layouterCreator,
IBreakerFactory breakerFactory,
ICriteriaFactory criteriaFactory,
IPlacerFactory placerFactory,
IGravityModifiersFactory gravityModifiersFactory,
IRowStrategy rowStrategy) {
this.layouterCreator = layouterCreator;
this.cacheStorage = layoutManager.getViewPositionsStorage();
this.layoutManager = layoutManager;
this.breakerFactory = breakerFactory;
this.criteriaFactory = criteriaFactory;
this.placerFactory = placerFactory;
this.gravityModifiersFactory = gravityModifiersFactory;
this.rowStrategy = rowStrategy;
}
public void addLayouterListener(@Nullable ILayouterListener layouterListener) {
if (layouterListener != null) {
layouterListeners.add(layouterListener);
}
}
private AbstractLayouter.Builder createBackwardBuilder() {
return layouterCreator.createBackwardBuilder();
}
private AbstractLayouter.Builder createForwardBuilder() {
return layouterCreator.createForwardBuilder();
}
private Rect createOffsetRectForBackwardLayouter(@NonNull AnchorViewState anchorRect) {
return layouterCreator.createOffsetRectForBackwardLayouter(anchorRect);
}
private Rect createOffsetRectForForwardLayouter(AnchorViewState anchorRect) {
return layouterCreator.createOffsetRectForForwardLayouter(anchorRect);
}
private ICanvas createCanvas() {
return layoutManager.getCanvas();
}
@NonNull
private AbstractLayouter.Builder fillBasicBuilder(AbstractLayouter.Builder builder) {
return builder.layoutManager(layoutManager)
.canvas(createCanvas())
.childGravityResolver(layoutManager.getChildGravityResolver())
.cacheStorage(cacheStorage)
.gravityModifiersFactory(gravityModifiersFactory)
.addLayouterListeners(layouterListeners);
}
@Nullable
public final ILayouter getBackwardLayouter(@NonNull AnchorViewState anchorRect) {
return fillBasicBuilder(createBackwardBuilder())
.offsetRect(createOffsetRectForBackwardLayouter(anchorRect))
.breaker(breakerFactory.createBackwardRowBreaker())
.finishingCriteria(criteriaFactory.getBackwardFinishingCriteria())
.rowStrategy(rowStrategy)
.placer(placerFactory.getAtStartPlacer())
.positionIterator(new DecrementalPositionIterator(layoutManager.getItemCount()))
.build();
}
@NonNull
public final ILayouter getForwardLayouter(@NonNull AnchorViewState anchorRect) {
return fillBasicBuilder(createForwardBuilder())
.offsetRect(createOffsetRectForForwardLayouter(anchorRect))
.breaker(breakerFactory.createForwardRowBreaker())
.finishingCriteria(criteriaFactory.getForwardFinishingCriteria())
.rowStrategy(new SkipLastRowStrategy(rowStrategy, !layoutManager.isStrategyAppliedWithLastRow()))
.placer(placerFactory.getAtEndPlacer())
.positionIterator(new IncrementalPositionIterator(layoutManager.getItemCount()))
.build();
}
@NonNull
public final ILayouter buildForwardLayouter(@NonNull ILayouter layouter) {
AbstractLayouter abstractLayouter = (AbstractLayouter) layouter;
abstractLayouter.setFinishingCriteria(criteriaFactory.getForwardFinishingCriteria());
abstractLayouter.setPlacer(placerFactory.getAtEndPlacer());
return abstractLayouter;
}
@NonNull
public final ILayouter buildBackwardLayouter(@NonNull ILayouter layouter) {
AbstractLayouter abstractLayouter = (AbstractLayouter) layouter;
abstractLayouter.setFinishingCriteria(criteriaFactory.getBackwardFinishingCriteria());
abstractLayouter.setPlacer(placerFactory.getAtStartPlacer());
return abstractLayouter;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/LayouterFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 1,052 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.support.v7.widget.RecyclerView;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
class ColumnsCreator implements ILayouterCreator {
private RecyclerView.LayoutManager layoutManager;
ColumnsCreator(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
@Override
public AbstractLayouter.Builder createBackwardBuilder() {
return LeftLayouter.newBuilder();
}
@Override
public AbstractLayouter.Builder createForwardBuilder() {
return RightLayouter.newBuilder();
}
@Override
public Rect createOffsetRectForBackwardLayouter(@NonNull AnchorViewState anchor) {
Rect anchorRect = anchor.getAnchorViewRect();
return new Rect(
anchorRect == null ? 0 : anchorRect.left,
0,
anchorRect == null ? 0 : anchorRect.right,
//we shouldn't include anchor view here, so anchorTop is a bottomOffset
anchorRect == null ? 0 : anchorRect.top);
}
@Override
public Rect createOffsetRectForForwardLayouter(@NonNull AnchorViewState anchor) {
Rect anchorRect = anchor.getAnchorViewRect();
return new Rect(
anchorRect == null ? anchor.getPosition() == 0 ? layoutManager.getPaddingLeft() : 0 : anchorRect.left,
//we should include anchor view here, so anchorTop is a topOffset
anchorRect == null ? layoutManager.getPaddingTop() : anchorRect.top,
anchorRect == null ? anchor.getPosition() == 0 ? layoutManager.getPaddingRight() : 0 : anchorRect.right,
0);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ColumnsCreator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 359 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.annotation.CallSuper;
import android.support.v7.widget.RecyclerView;
public class MeasureSupporter extends RecyclerView.AdapterDataObserver implements IMeasureSupporter {
private RecyclerView.LayoutManager lm;
private boolean isAfterRemoving;
private int measuredWidth;
private int measuredHeight;
private boolean isRegistered;
/**
* width of RecyclerView before removing item
*/
private Integer beforeRemovingWidth = null;
/**
* width which we receive after {@link RecyclerView.LayoutManager#onLayoutChildren} method finished.
* Contains correct width after auto-measuring
*/
private int autoMeasureWidth = 0;
/**
* height of RecyclerView before removing item
*/
private Integer beforeRemovingHeight = null;
/**
* height which we receive after {@link RecyclerView.LayoutManager#onLayoutChildren} method finished.
* Contains correct height after auto-measuring
*/
private int autoMeasureHeight = 0;
public MeasureSupporter(RecyclerView.LayoutManager lm) {
this.lm = lm;
}
@Override
public void onSizeChanged() {
autoMeasureWidth = lm.getWidth();
autoMeasureHeight = lm.getHeight();
}
boolean isAfterRemoving() {
return isAfterRemoving;
}
@Override
public int getMeasuredWidth() {
return measuredWidth;
}
private void setMeasuredWidth(int measuredWidth) {
this.measuredWidth = measuredWidth;
}
@Override
public int getMeasuredHeight() {
return measuredHeight;
}
@Override
public boolean isRegistered() {
return isRegistered;
}
@Override
public void setRegistered(boolean isRegistered) {
this.isRegistered = isRegistered;
}
private void setMeasuredHeight(int measuredHeight) {
this.measuredHeight = measuredHeight;
}
@Override
@CallSuper
public void measure(int autoWidth, int autoHeight) {
if (isAfterRemoving()) {
setMeasuredWidth(Math.max(autoWidth, beforeRemovingWidth));
setMeasuredHeight(Math.max(autoHeight, beforeRemovingHeight));
} else {
setMeasuredWidth(autoWidth);
setMeasuredHeight(autoHeight);
}
}
@Override
public void onItemsRemoved(final RecyclerView recyclerView){
//subscribe to next animations tick
lm.postOnAnimation(new Runnable() {
private void onFinished() {
//when removing animation finished return auto-measuring back
isAfterRemoving = false;
// and process measure again
lm.requestLayout();
}
@Override
public void run() {
if (recyclerView.getItemAnimator() != null) {
//listen removing animation
recyclerView.getItemAnimator().isRunning(new RecyclerView.ItemAnimator.ItemAnimatorFinishedListener() {
@Override
public void onAnimationsFinished() {
onFinished();
}
});
} else {
onFinished();
}
}
});
}
@Override
@CallSuper
public void onItemRangeRemoved(int positionStart, int itemCount) {
super.onItemRangeRemoved(positionStart, itemCount);
/** we detected removing event, so should process measuring manually
* @see <a href="path_to_url">Stack Overflow issue</a>
*/
isAfterRemoving = true;
beforeRemovingWidth = autoMeasureWidth;
beforeRemovingHeight = autoMeasureHeight;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/MeasureSupporter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 725 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.view.View;
class RightLayouter extends AbstractLayouter {
private boolean isPurged;
private RightLayouter(Builder builder) {
super(builder);
}
public static Builder newBuilder() {
return new Builder();
}
@Override
Rect createViewRect(View view) {
Rect viewRect = new Rect(viewLeft, viewTop, viewLeft + getCurrentViewWidth(), viewTop + getCurrentViewHeight());
viewBottom = viewRect.bottom;
viewTop = viewBottom;
viewRight = Math.max(viewRight, viewRect.right);
return viewRect;
}
@Override
boolean isReverseOrder() {
return false;
}
@Override
void onPreLayout() {
if (!rowViews.isEmpty()) {
//todo this isn't great place for that. Should be refactored somehow
if (!isPurged) {
isPurged = true;
getCacheStorage().purgeCacheFromPosition(getLayoutManager().getPosition(rowViews.get(0).second));
}
//cache only when go down
getCacheStorage().storeRow(rowViews);
}
}
@Override
void onAfterLayout() {
//go to next column, increase left coordinate, reset top
viewLeft = getViewRight();
viewTop = getCanvasTopBorder();
}
@Override
boolean isAttachedViewFromNewRow(View view) {
int leftOfCurrentView = getLayoutManager().getDecoratedLeft(view);
int topOfCurrentView = getLayoutManager().getDecoratedTop(view);
return viewRight <= leftOfCurrentView
&& topOfCurrentView < viewTop;
}
@Override
void onInterceptAttachView(View view) {
viewTop = getLayoutManager().getDecoratedBottom(view);
viewLeft = getLayoutManager().getDecoratedLeft(view);
viewRight = Math.max(viewRight, getLayoutManager().getDecoratedRight(view));
}
@Override
public int getStartRowBorder() {
return getViewLeft();
}
@Override
public int getEndRowBorder() {
return getViewRight();
}
@Override
public int getRowLength() {
return viewTop - getCanvasTopBorder();
}
public static final class Builder extends AbstractLayouter.Builder {
private Builder() {
}
@NonNull
public RightLayouter createLayouter() {
return new RightLayouter(this);
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RightLayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 553 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
public class Item {
private Rect viewRect;
private int viewPosition;
public Item(Rect viewRect, int viewPosition) {
this.viewRect = viewRect;
this.viewPosition = viewPosition;
}
public Rect getViewRect() {
return viewRect;
}
public int getViewPosition() {
return viewPosition;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Item item = (Item) o;
return viewPosition == item.viewPosition;
}
@Override
public int hashCode() {
return viewPosition;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/Item.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 168 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.v7.widget.RecyclerView;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.gravity.IGravityModifiersFactory;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategy;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IBreakerFactory;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
class RTLRowsCreator implements ILayouterCreator {
private RecyclerView.LayoutManager layoutManager;
RTLRowsCreator(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
//---- up layouter below
@Override
public Rect createOffsetRectForBackwardLayouter(AnchorViewState anchor) {
Rect anchorRect = anchor.getAnchorViewRect();
return new Rect(
//we shouldn't include anchor view here, so anchorLeft is a rightOffset
anchorRect == null ? 0 : anchorRect.right,
anchorRect == null ? 0 : anchorRect.top,
0,
anchorRect == null ? 0 : anchorRect.bottom);
}
@Override
public AbstractLayouter.Builder createBackwardBuilder() {
return RTLUpLayouter.newBuilder();
}
//---- down layouter below
@Override
public AbstractLayouter.Builder createForwardBuilder() {
return RTLDownLayouter.newBuilder();
}
@Override
public Rect createOffsetRectForForwardLayouter(AnchorViewState anchor) {
Rect anchorRect = anchor.getAnchorViewRect();
return new Rect(
0,
anchorRect == null ? anchor.getPosition() == 0 ? layoutManager.getPaddingTop() : 0 : anchorRect.top,
anchorRect == null ? layoutManager.getPaddingRight() : anchorRect.right,
anchorRect == null ? anchor.getPosition() == 0 ? layoutManager.getPaddingBottom() : 0 : anchorRect.bottom);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RTLRowsCreator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 465 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.v7.widget.RecyclerView;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategyFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IBreakerFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IRowBreaker;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
interface IOrientationStateFactory {
ILayouterCreator createLayouterCreator(RecyclerView.LayoutManager lm);
IRowStrategyFactory createRowStrategyFactory();
IBreakerFactory createDefaultBreaker();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/IOrientationStateFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 148 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.v7.widget.RecyclerView;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategyFactory;
import com.beloo.widget.chipslayoutmanager.gravity.LTRRowStrategyFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.IBreakerFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.LTRRowBreakerFactory;
class LTRRowsOrientationStateFactory implements IOrientationStateFactory {
@Override
public ILayouterCreator createLayouterCreator(RecyclerView.LayoutManager lm) {
return new LTRRowsCreator(lm);
}
@Override
public IRowStrategyFactory createRowStrategyFactory() {
return new LTRRowStrategyFactory();
}
@Override
public IBreakerFactory createDefaultBreaker() {
return new LTRRowBreakerFactory();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/LTRRowsOrientationStateFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 192 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.IBorder;
public interface ICanvas extends IBorder {
Rect getCanvasRect();
Rect getViewRect(View view);
boolean isInside(Rect rectCandidate);
boolean isInside(View viewCandidate);
boolean isFullyVisible(View view);
boolean isFullyVisible(Rect rect);
/** calculate border state of layout manager after filling children*/
void findBorderViews();
View getTopView();
View getBottomView();
View getLeftView();
View getRightView();
Integer getMinPositionOnScreen();
Integer getMaxPositionOnScreen();
boolean isFirstItemAdded();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ICanvas.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 152 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.util.Pair;
import android.view.View;
import java.util.Collections;
class LeftLayouter extends AbstractLayouter {
private LeftLayouter(Builder builder) {
super(builder);
}
public static Builder newBuilder() {
return new Builder();
}
@Override
Rect createViewRect(View view) {
int left = viewRight - getCurrentViewWidth();
int viewTop = viewBottom - getCurrentViewHeight();
Rect viewRect = new Rect(left, viewTop, viewRight, viewBottom);
viewBottom = viewRect.top;
return viewRect;
}
@Override
boolean isReverseOrder() {
return true;
}
@Override
void onPreLayout() {
int topOffsetOfRow = viewBottom - getCanvasTopBorder();
viewBottom = 0;
for (Pair<Rect, View> columnViewRectPair : rowViews) {
Rect viewRect = columnViewRectPair.first;
viewRect.top = viewRect.top - topOffsetOfRow;
viewRect.bottom = viewRect.bottom - topOffsetOfRow;
viewBottom = Math.max(viewBottom, viewRect.bottom);
viewLeft = Math.min(viewLeft, viewRect.left);
viewRight = Math.max(viewRight, viewRect.right);
}
}
@Override
void onAfterLayout() {
viewBottom = getCanvasBottomBorder();
viewRight = viewLeft;
}
@Override
boolean isAttachedViewFromNewRow(View view) {
int bottomOfCurrentView = getLayoutManager().getDecoratedBottom(view);
int rightOfCurrentView = getLayoutManager().getDecoratedRight(view);
return viewLeft >= rightOfCurrentView
&& bottomOfCurrentView > viewBottom;
}
@Override
void onInterceptAttachView(View view) {
if (viewBottom != getCanvasBottomBorder() && viewBottom - getCurrentViewHeight() < getCanvasTopBorder()) {
//new column
viewBottom = getCanvasBottomBorder();
viewRight = viewLeft;
} else {
viewBottom = getLayoutManager().getDecoratedTop(view);
}
viewLeft = Math.min(viewLeft, getLayoutManager().getDecoratedLeft(view));
}
@Override
public int getStartRowBorder() {
return getViewLeft();
}
@Override
public int getEndRowBorder() {
return getViewRight();
}
@Override
public int getRowLength() {
return viewBottom - getCanvasTopBorder();
}
public static final class Builder extends AbstractLayouter.Builder {
private Builder() {
}
@NonNull
public LeftLayouter createLayouter() {
return new LeftLayouter(this);
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/LeftLayouter.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 609 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.annotation.IntRange;
class IncrementalPositionIterator extends AbstractPositionIterator {
IncrementalPositionIterator(@IntRange(from = 0) int itemCount) {
super(itemCount);
}
@Override
public boolean hasNext() {
return pos < itemCount;
}
@Override
public Integer next() {
if (!hasNext()) throw new IllegalStateException("position out of bounds reached");
return pos++;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/IncrementalPositionIterator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 105 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.support.v7.widget.RecyclerView;
class ColumnSquare extends Square {
ColumnSquare(RecyclerView.LayoutManager lm) {
super(lm);
}
public final int getCanvasRightBorder() {
return lm.getWidth();
}
public final int getCanvasBottomBorder() {
return lm.getHeight() - lm.getPaddingBottom();
}
public final int getCanvasLeftBorder() {
return 0;
}
public final int getCanvasTopBorder() {
return lm.getPaddingTop();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ColumnSquare.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 121 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.graphics.Rect;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
interface ILayouterCreator {
//---- up layouter below
Rect createOffsetRectForBackwardLayouter(@NonNull AnchorViewState anchorRect);
AbstractLayouter.Builder createBackwardBuilder();
AbstractLayouter.Builder createForwardBuilder();
Rect createOffsetRectForForwardLayouter(AnchorViewState anchorRect);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ILayouterCreator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 109 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.IScrollingController;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.anchor.IAnchorFactory;
import com.beloo.widget.chipslayoutmanager.anchor.RowsAnchorFactory;
import com.beloo.widget.chipslayoutmanager.gravity.RowGravityModifiersFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.DecoratorBreakerFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.AbstractCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.InfiniteCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.RowsCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
import com.beloo.widget.chipslayoutmanager.util.StateHelper;
public class RowsStateFactory implements IStateFactory {
private ChipsLayoutManager lm;
public RowsStateFactory(ChipsLayoutManager lm) {
this.lm = lm;
}
private IOrientationStateFactory createOrientationStateFactory() {
return lm.isLayoutRTL() ? new RTLRowsOrientationStateFactory() : new LTRRowsOrientationStateFactory();
}
@Override
public LayouterFactory createLayouterFactory(ICriteriaFactory criteriaFactory, IPlacerFactory placerFactory) {
IOrientationStateFactory orientationStateFactory = createOrientationStateFactory();
return new LayouterFactory(lm,
orientationStateFactory.createLayouterCreator(lm),
new DecoratorBreakerFactory(
lm.getViewPositionsStorage(),
lm.getRowBreaker(),
lm.getMaxViewsInRow(),
orientationStateFactory.createDefaultBreaker()),
criteriaFactory,
placerFactory,
new RowGravityModifiersFactory(),
orientationStateFactory.createRowStrategyFactory().createRowStrategy(lm.getRowStrategyType()));
}
@Override
public AbstractCriteriaFactory createDefaultFinishingCriteriaFactory() {
return StateHelper.isInfinite(this)? new InfiniteCriteriaFactory() : new RowsCriteriaFactory();
}
@Override
public IAnchorFactory anchorFactory() {
return new RowsAnchorFactory(lm, lm.getCanvas());
}
@Override
public IScrollingController scrollingController() {
return lm.verticalScrollingController();
}
@Override
public ICanvas createCanvas() {
return new RowSquare(lm);
}
@Override
public int getSizeMode() {
return lm.getHeightMode();
}
@Override
public int getStart() {
return 0;
}
@Override
public int getStart(View view) {
return lm.getDecoratedTop(view);
}
@Override
public int getStart(AnchorViewState anchor) {
return anchor.getAnchorViewRect().top;
}
@Override
public int getEnd() {
return lm.getHeight();
}
@Override
public int getEnd(View view) {
return lm.getDecoratedBottom(view);
}
@Override
public int getEnd(AnchorViewState anchor) {
return anchor.getAnchorViewRect().bottom;
}
@Override
public int getEndViewPosition() {
return lm.getPosition(lm.getCanvas().getRightView());
}
@Override
public int getStartAfterPadding() {
return lm.getPaddingTop();
}
@Override
public int getStartViewPosition() {
return lm.getPosition(lm.getCanvas().getLeftView());
}
@Override
public int getEndAfterPadding() {
return lm.getHeight() - lm.getPaddingBottom();
}
@Override
public int getStartViewBound() {
return getStart(lm.getCanvas().getTopView());
}
@Override
public int getEndViewBound() {
return getEnd(lm.getCanvas().getBottomView());
}
@Override
public int getTotalSpace() {
return lm.getHeight() - lm.getPaddingTop()
- lm.getPaddingBottom();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/RowsStateFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 886 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
public interface ILayouterListener {
void onLayoutRow(ILayouter layouter);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ILayouterListener.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 32 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaLeftAdditionalWidth extends FinishingCriteriaDecorator {
private int additionalWidth;
CriteriaLeftAdditionalWidth(IFinishingCriteria finishingCriteria, int additionalWidth) {
super(finishingCriteria);
this.additionalWidth = additionalWidth;
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
int leftBorder = abstractLayouter.getCanvasLeftBorder();
return super.isFinishedLayouting(abstractLayouter) &&
//if additional height filled
abstractLayouter.getViewRight() < leftBorder - additionalWidth;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaLeftAdditionalWidth.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 148 |
```java
package com.beloo.widget.chipslayoutmanager.layouter;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.IScrollingController;
import com.beloo.widget.chipslayoutmanager.anchor.AnchorViewState;
import com.beloo.widget.chipslayoutmanager.anchor.ColumnsAnchorFactory;
import com.beloo.widget.chipslayoutmanager.anchor.IAnchorFactory;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.gravity.ColumnGravityModifiersFactory;
import com.beloo.widget.chipslayoutmanager.gravity.ColumnStrategyFactory;
import com.beloo.widget.chipslayoutmanager.gravity.IRowStrategyFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.DecoratorBreakerFactory;
import com.beloo.widget.chipslayoutmanager.layouter.breaker.ColumnBreakerFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.AbstractCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ColumnsCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.ICriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.criteria.InfiniteCriteriaFactory;
import com.beloo.widget.chipslayoutmanager.layouter.placer.IPlacerFactory;
import com.beloo.widget.chipslayoutmanager.util.StateHelper;
public class ColumnsStateFactory implements IStateFactory {
private ChipsLayoutManager lm;
private IRowStrategyFactory rowStrategyFactory;
public ColumnsStateFactory(ChipsLayoutManager lm) {
this.lm = lm;
rowStrategyFactory = new ColumnStrategyFactory();
}
@Override
public LayouterFactory createLayouterFactory(ICriteriaFactory criteriaFactory, IPlacerFactory placerFactory) {
IViewCacheStorage cacheStorage = lm.getViewPositionsStorage();
return createColumnLayouterFactory(criteriaFactory, placerFactory, cacheStorage);
}
private LayouterFactory createColumnLayouterFactory(ICriteriaFactory criteriaFactory, IPlacerFactory placerFactory, IViewCacheStorage cacheStorage) {
return new LayouterFactory(lm,
new ColumnsCreator(lm),
new DecoratorBreakerFactory(cacheStorage, lm.getRowBreaker(), lm.getMaxViewsInRow(), new ColumnBreakerFactory()),
criteriaFactory,
placerFactory,
new ColumnGravityModifiersFactory(),
rowStrategyFactory.createRowStrategy(lm.getRowStrategyType()));
}
@Override
public AbstractCriteriaFactory createDefaultFinishingCriteriaFactory() {
return StateHelper.isInfinite(this)? new InfiniteCriteriaFactory() : new ColumnsCriteriaFactory();
}
@Override
public IAnchorFactory anchorFactory() {
return new ColumnsAnchorFactory(lm, lm.getCanvas());
}
@Override
public IScrollingController scrollingController() {
return lm.horizontalScrollingController();
}
@Override
public ICanvas createCanvas() {
return new ColumnSquare(lm);
}
@Override
public int getSizeMode() {
return lm.getWidthMode();
}
@Override
public int getStart() {
return 0;
}
@Override
public int getStart(View view) {
return lm.getDecoratedLeft(view);
}
@Override
public int getStart(AnchorViewState anchor) {
return anchor.getAnchorViewRect().left;
}
@Override
public int getEnd() {
return lm.getWidth();
}
@Override
public int getEnd(View view) {
return lm.getDecoratedRight(view);
}
@Override
public int getEnd(AnchorViewState anchor) {
return anchor.getAnchorViewRect().right;
}
@Override
public int getEndViewPosition() {
return lm.getPosition(lm.getCanvas().getBottomView());
}
@Override
public int getStartAfterPadding() {
return lm.getPaddingLeft();
}
@Override
public int getStartViewPosition() {
return lm.getPosition(lm.getCanvas().getTopView());
}
@Override
public int getEndAfterPadding() {
return lm.getWidth() - lm.getPaddingRight();
}
@Override
public int getStartViewBound() {
return getStart(lm.getCanvas().getLeftView());
}
@Override
public int getEndViewBound() {
return getEnd(lm.getCanvas().getRightView());
}
@Override
public int getTotalSpace() {
return lm.getWidth() - lm.getPaddingLeft()
- lm.getPaddingRight();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/ColumnsStateFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 960 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.support.annotation.NonNull;
public class RowsCriteriaFactory extends AbstractCriteriaFactory implements ICriteriaFactory {
@NonNull
@Override
public IFinishingCriteria getBackwardFinishingCriteria() {
IFinishingCriteria criteria = new CriteriaUpLayouterFinished();
if (additionalLength != 0) {
criteria = new CriteriaUpAdditionalHeight(criteria, additionalLength);
}
return criteria;
}
@NonNull
@Override
public IFinishingCriteria getForwardFinishingCriteria() {
IFinishingCriteria criteria = new CriteriaDownLayouterFinished();
if (additionalLength != 0) {
criteria = new CriteriaDownAdditionalHeight(criteria, additionalLength);
}
if (additionalRowCount != 0) {
criteria = new CriteriaAdditionalRow(criteria, additionalRowCount);
}
return criteria;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/RowsCriteriaFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 192 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaRightLayouterFinished implements IFinishingCriteria {
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
return abstractLayouter.getViewLeft() >= abstractLayouter.getCanvasRightBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaRightLayouterFinished.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 80 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaUpLayouterFinished implements IFinishingCriteria {
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
return abstractLayouter.getViewBottom() <= abstractLayouter.getCanvasTopBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaUpLayouterFinished.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 80 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.support.annotation.NonNull;
public class PreLayoutCriteriaFactory implements ICriteriaFactory {
private int additionalHeight;
private int additionalRowsCount;
public PreLayoutCriteriaFactory(int additionalHeight, int additionalRowsCount) {
this.additionalHeight = additionalHeight;
this.additionalRowsCount = additionalRowsCount;
}
@NonNull
@Override
public IFinishingCriteria getBackwardFinishingCriteria() {
return new CriteriaUpAdditionalHeight(new CriteriaUpLayouterFinished(), additionalHeight);
}
@NonNull
@Override
public IFinishingCriteria getForwardFinishingCriteria() {
return new CriteriaAdditionalRow(
new CriteriaDownAdditionalHeight(new CriteriaDownLayouterFinished(), additionalHeight),
additionalRowsCount);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/PreLayoutCriteriaFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 173 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.ILayouter;
import com.beloo.widget.chipslayoutmanager.layouter.ILayouterListener;
class CriteriaAdditionalRow extends FinishingCriteriaDecorator implements IFinishingCriteria, ILayouterListener {
private int requiredRowsCount;
private int additionalRowsCount;
CriteriaAdditionalRow(IFinishingCriteria finishingCriteria, int requiredRowsCount) {
super(finishingCriteria);
this.requiredRowsCount = requiredRowsCount;
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
abstractLayouter.addLayouterListener(this);
return super.isFinishedLayouting(abstractLayouter) && additionalRowsCount >= requiredRowsCount;
}
@Override
public void onLayoutRow(ILayouter layouter) {
if (super.isFinishedLayouting((AbstractLayouter) layouter)) {
additionalRowsCount++;
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaAdditionalRow.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 227 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.support.annotation.NonNull;
public class ColumnsCriteriaFactory extends AbstractCriteriaFactory {
@SuppressWarnings("UnnecessaryLocalVariable")
@NonNull
@Override
public IFinishingCriteria getBackwardFinishingCriteria() {
IFinishingCriteria criteria = new CriteriaLeftLayouterFinished();
if (additionalLength != 0) {
criteria = new CriteriaLeftAdditionalWidth(criteria, additionalLength);
}
return criteria;
}
@NonNull
@Override
public IFinishingCriteria getForwardFinishingCriteria() {
IFinishingCriteria criteria = new CriteriaRightLayouterFinished();
if (additionalLength != 0) {
criteria = new CriteriaRightAdditionalWidth(criteria, additionalLength);
}
if (additionalRowCount != 0) {
criteria = new CriteriaAdditionalRow(criteria, additionalRowCount);
}
return criteria;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/ColumnsCriteriaFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 197 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaUpAdditionalHeight extends FinishingCriteriaDecorator {
private int additionalHeight;
CriteriaUpAdditionalHeight(IFinishingCriteria finishingCriteria, int additionalHeight) {
super(finishingCriteria);
this.additionalHeight = additionalHeight;
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
int topBorder = abstractLayouter.getCanvasTopBorder();
return super.isFinishedLayouting(abstractLayouter) &&
//if additional height filled
abstractLayouter.getViewBottom() < topBorder - additionalHeight;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaUpAdditionalHeight.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 148 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.util.Log;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaLeftLayouterFinished implements IFinishingCriteria {
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
return abstractLayouter.getViewRight() <= abstractLayouter.getCanvasLeftBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaLeftLayouterFinished.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 85 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.support.annotation.IntRange;
public abstract class AbstractCriteriaFactory implements ICriteriaFactory {
int additionalLength;
int additionalRowCount;
public void setAdditionalLength(@IntRange(from = 0) int additionalHeight) {
if (additionalHeight < 0) throw new IllegalArgumentException("additional height can't be negative");
this.additionalLength = additionalHeight;
}
public void setAdditionalRowsCount(int additionalRowCount) {
this.additionalRowCount = additionalRowCount;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/AbstractCriteriaFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 114 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaDownAdditionalHeight extends FinishingCriteriaDecorator {
private int additionalHeight;
CriteriaDownAdditionalHeight(IFinishingCriteria finishingCriteria, int additionalHeight) {
super(finishingCriteria);
this.additionalHeight = additionalHeight;
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
int bottomBorder = abstractLayouter.getCanvasBottomBorder();
return super.isFinishedLayouting(abstractLayouter) &&
//if additional height filled
abstractLayouter.getViewTop() > bottomBorder + additionalHeight;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaDownAdditionalHeight.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 148 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaRightAdditionalWidth extends FinishingCriteriaDecorator {
private int additionalWidth;
CriteriaRightAdditionalWidth(IFinishingCriteria finishingCriteria, int additionalWidth) {
super(finishingCriteria);
this.additionalWidth = additionalWidth;
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
int rightBorder = abstractLayouter.getCanvasRightBorder();
return super.isFinishedLayouting(abstractLayouter) &&
//if additional height filled
abstractLayouter.getViewLeft() > rightBorder + additionalWidth;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaRightAdditionalWidth.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 148 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.support.annotation.NonNull;
public interface ICriteriaFactory {
@NonNull
IFinishingCriteria getBackwardFinishingCriteria();
@NonNull
IFinishingCriteria getForwardFinishingCriteria();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/ICriteriaFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 58 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
/** when using this criteria {@link AbstractLayouter} doesn't able to finish himself, you should only stop calling placeView outside */
class InfiniteCriteria implements IFinishingCriteria {
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
return false;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/InfiniteCriteria.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 91 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CriteriaDownLayouterFinished implements IFinishingCriteria {
private boolean isFinished;
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
isFinished = isFinished || abstractLayouter.getViewTop() >= abstractLayouter.getCanvasBottomBorder();
return isFinished;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaDownLayouterFinished.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 96 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import android.support.annotation.NonNull;
public class InfiniteCriteriaFactory extends AbstractCriteriaFactory implements ICriteriaFactory {
@NonNull
@Override
public IFinishingCriteria getBackwardFinishingCriteria() {
return new InfiniteCriteria();
}
@NonNull
@Override
public IFinishingCriteria getForwardFinishingCriteria() {
return new InfiniteCriteria();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/InfiniteCriteriaFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 94 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
abstract class FinishingCriteriaDecorator implements IFinishingCriteria {
private IFinishingCriteria finishingCriteria;
FinishingCriteriaDecorator(IFinishingCriteria finishingCriteria) {
this.finishingCriteria = finishingCriteria;
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
return finishingCriteria.isFinishedLayouting(abstractLayouter);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/FinishingCriteriaDecorator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 109 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.ILayouter;
import com.beloo.widget.chipslayoutmanager.layouter.ILayouterListener;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
public class CriteriaPolitePositionReached extends FinishingCriteriaDecorator implements IFinishingCriteria, ILayouterListener {
private boolean isPositionReached;
private int reachedPosition;
CriteriaPolitePositionReached(AbstractLayouter abstractLayouter, IFinishingCriteria finishingCriteria, int reachedPosition) {
super(finishingCriteria);
this.reachedPosition = reachedPosition;
abstractLayouter.addLayouterListener(this);
}
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
boolean isFinishedFlow = super.isFinishedLayouting(abstractLayouter);
return isFinishedFlow || isPositionReached;
}
@Override
public void onLayoutRow(ILayouter layouter) {
if (isPositionReached) return;
if (layouter.getRowSize() == 0) return;
for (Item item : layouter.getCurrentRowItems()) {
if (item.getViewPosition() == reachedPosition) {
isPositionReached = true;
return;
}
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/CriteriaPolitePositionReached.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 292 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
public class EmtpyCriteria implements IFinishingCriteria {
@Override
public boolean isFinishedLayouting(AbstractLayouter abstractLayouter) {
return true;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/EmtpyCriteria.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 67 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.criteria;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
public interface IFinishingCriteria {
/** check if layouting finished by criteria */
boolean isFinishedLayouting(AbstractLayouter abstractLayouter);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/criteria/IFinishingCriteria.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 60 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class BackwardBreakerContract extends RowBreakerDecorator{
private IRowBreaker breaker;
BackwardBreakerContract(IRowBreaker breaker, ILayoutRowBreaker decorate) {
super(decorate);
this.breaker = breaker;
}
@Override
public boolean isRowBroke(AbstractLayouter al) {
return super.isRowBroke(al) ||
breaker.isItemBreakRow(al.getCurrentViewPosition());
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/BackwardBreakerContract.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 126 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
public class LTRRowBreakerFactory implements IBreakerFactory {
@Override
public ILayoutRowBreaker createBackwardRowBreaker() {
return new LTRBackwardRowBreaker();
}
@Override
public ILayoutRowBreaker createForwardRowBreaker() {
return new LTRForwardRowBreaker();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/LTRRowBreakerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 92 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
public class LTRBackwardColumnBreaker implements ILayoutRowBreaker {
@Override
public boolean isRowBroke(AbstractLayouter al) {
return al.getViewBottom() - al.getCurrentViewHeight() < al.getCanvasTopBorder()
&& al.getViewBottom() < al.getCanvasBottomBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/LTRBackwardColumnBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 98 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
/** brakes the row in case max views size in row reached */
public class MaxViewsBreaker extends RowBreakerDecorator {
private int maxViewsInRow;
MaxViewsBreaker(int maxViewsInRow, ILayoutRowBreaker decorate) {
super(decorate);
this.maxViewsInRow = maxViewsInRow;
}
@Override
public boolean isRowBroke(AbstractLayouter al) {
return super.isRowBroke(al)
|| al.getRowSize() >= maxViewsInRow;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/MaxViewsBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 143 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import android.support.annotation.IntRange;
/** determines whether LM should break row from view position */
public interface IRowBreaker {
/** @return `true` means that it is the last view in the row.
* `false` means that breaking behaviour about current view will be based on another conditions */
boolean isItemBreakRow(@IntRange(from = 0) int position);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/IRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 97 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
public class ColumnBreakerFactory implements IBreakerFactory {
@Override
public ILayoutRowBreaker createBackwardRowBreaker() {
return new LTRBackwardColumnBreaker();
}
@Override
public ILayoutRowBreaker createForwardRowBreaker() {
return new LTRForwardColumnBreaker();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/ColumnBreakerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 90 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
public class EmptyRowBreaker implements IRowBreaker {
@Override
public boolean isItemBreakRow(int position) {
return false;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/EmptyRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 49 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
public interface IBreakerFactory {
ILayoutRowBreaker createBackwardRowBreaker();
ILayoutRowBreaker createForwardRowBreaker();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/IBreakerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 48 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class RowBreakerDecorator implements ILayoutRowBreaker {
private ILayoutRowBreaker decorate;
RowBreakerDecorator(ILayoutRowBreaker decorate) {
this.decorate = decorate;
}
@Override
public boolean isRowBroke(AbstractLayouter al) {
return decorate.isRowBroke(al);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/RowBreakerDecorator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 101 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
/** this is basis row breaker for {@link com.beloo.widget.chipslayoutmanager.layouter.LTRDownLayouter} */
class LTRForwardRowBreaker implements ILayoutRowBreaker {
@Override
public boolean isRowBroke(AbstractLayouter al) {
return al.getViewLeft() > al.getCanvasLeftBorder()
&& al.getViewLeft() + al.getCurrentViewWidth() > al.getCanvasRightBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/LTRForwardRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 122 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
public interface ILayoutRowBreaker {
boolean isRowBroke(AbstractLayouter al);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/ILayoutRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 50 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
/** this is basis row breaker for {@link com.beloo.widget.chipslayoutmanager.layouter.RTLDownLayouter} */
class RTLForwardRowBreaker implements ILayoutRowBreaker {
@Override
public boolean isRowBroke(AbstractLayouter al) {
return al.getViewRight() < al.getCanvasRightBorder()
&& al.getViewRight() - al.getCurrentViewWidth() < al.getCanvasLeftBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/RTLForwardRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 121 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
public class DecoratorBreakerFactory implements IBreakerFactory {
private IBreakerFactory breakerFactory;
private IViewCacheStorage cacheStorage;
private IRowBreaker rowBreaker;
/** Max items in row restriction. Layout of row should be stopped when this count of views reached*/
@Nullable
private Integer maxViewsInRow;
public DecoratorBreakerFactory(@NonNull IViewCacheStorage cacheStorage,
@NonNull IRowBreaker rowBreaker,
@Nullable Integer maxViewsInRow,
@NonNull IBreakerFactory breakerFactory) {
this.cacheStorage = cacheStorage;
this.rowBreaker = rowBreaker;
this.maxViewsInRow = maxViewsInRow;
this.breakerFactory = breakerFactory;
}
@Override
public ILayoutRowBreaker createBackwardRowBreaker() {
ILayoutRowBreaker breaker = breakerFactory.createBackwardRowBreaker();
breaker = new BackwardBreakerContract(rowBreaker, new CacheRowBreaker(cacheStorage, breaker));
if (maxViewsInRow != null) {
breaker = new MaxViewsBreaker(maxViewsInRow, breaker);
}
return breaker;
}
@Override
public ILayoutRowBreaker createForwardRowBreaker() {
ILayoutRowBreaker breaker = breakerFactory.createForwardRowBreaker();
breaker = new ForwardBreakerContract(rowBreaker, breaker);
if (maxViewsInRow != null) {
breaker = new MaxViewsBreaker(maxViewsInRow, breaker);
}
return breaker;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/DecoratorBreakerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 380 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
public class RTLRowBreakerFactory implements IBreakerFactory {
@Override
public ILayoutRowBreaker createBackwardRowBreaker() {
return new RTLBackwardRowBreaker();
}
@Override
public ILayoutRowBreaker createForwardRowBreaker() {
return new RTLForwardRowBreaker();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/RTLRowBreakerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 89 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.cache.IViewCacheStorage;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class CacheRowBreaker extends RowBreakerDecorator {
private IViewCacheStorage cacheStorage;
CacheRowBreaker(IViewCacheStorage cacheStorage, ILayoutRowBreaker decorate) {
super(decorate);
this.cacheStorage = cacheStorage;
}
@Override
public boolean isRowBroke(AbstractLayouter al) {
boolean stopDueToCache = cacheStorage.isPositionEndsRow(al.getCurrentViewPosition());
return super.isRowBroke(al) || stopDueToCache;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/CacheRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 155 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
public class LTRForwardColumnBreaker implements ILayoutRowBreaker {
@Override
public boolean isRowBroke(AbstractLayouter al) {
return al.getViewTop() > al.getCanvasTopBorder()
&& al.getViewTop() + al.getCurrentViewHeight() > al.getCanvasBottomBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/LTRForwardColumnBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 97 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
/** this is basis row breaker for {@link com.beloo.widget.chipslayoutmanager.layouter.RTLUpLayouter} */
class RTLBackwardRowBreaker implements ILayoutRowBreaker {
@Override
public boolean isRowBroke(AbstractLayouter al) {
return al.getViewLeft() + al.getCurrentViewWidth() > al.getCanvasRightBorder()
&& al.getViewLeft() > al.getCanvasLeftBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/RTLBackwardRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 122 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
/** this is basis row breaker for {@link com.beloo.widget.chipslayoutmanager.layouter.LTRUpLayouter} */
class LTRBackwardRowBreaker implements ILayoutRowBreaker {
@Override
public boolean isRowBroke(AbstractLayouter al) {
return al.getViewRight() - al.getCurrentViewWidth() < al.getCanvasLeftBorder()
&& al.getViewRight() < al.getCanvasRightBorder();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/LTRBackwardRowBreaker.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 123 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.breaker;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
class ForwardBreakerContract extends RowBreakerDecorator {
private IRowBreaker breaker;
ForwardBreakerContract(IRowBreaker breaker, ILayoutRowBreaker decorate) {
super(decorate);
this.breaker = breaker;
}
@Override
public boolean isRowBroke(AbstractLayouter al) {
return super.isRowBroke(al) ||
(al.getCurrentViewPosition() != 0 && breaker.isItemBreakRow(al.getCurrentViewPosition() - 1));
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/breaker/ForwardBreakerContract.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 138 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import com.beloo.widget.chipslayoutmanager.R;
class DisappearingViewAtEndPlacer extends AbstractPlacer {
DisappearingViewAtEndPlacer(RecyclerView.LayoutManager layoutManager) {
super(layoutManager);
}
@Override
public void addView(View view) {
getLayoutManager().addDisappearingView(view);
// Log.i("added disappearing view, position = " + getLayoutManager().getPosition(view));
// Log.d("name = " + ((TextView)view.findViewById(R.id.tvName)).getText().toString());
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/DisappearingViewAtEndPlacer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 154 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
public interface IPlacerFactory {
IPlacer getAtStartPlacer();
IPlacer getAtEndPlacer();
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/IPlacerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 43 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
public class PlacerFactory {
private ChipsLayoutManager lm;
public PlacerFactory(ChipsLayoutManager lm) {
this.lm = lm;
}
public IPlacerFactory createRealPlacerFactory() {
return new RealPlacerFactory(lm);
}
public IPlacerFactory createDisappearingPlacerFactory() {
return new DisappearingPlacerFactory(lm);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/PlacerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 116 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.view.View;
public interface IPlacer {
void addView(View view);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/IPlacer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 34 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import com.beloo.widget.chipslayoutmanager.R;
class DisappearingViewAtStartPlacer extends AbstractPlacer {
DisappearingViewAtStartPlacer(RecyclerView.LayoutManager layoutManager) {
super(layoutManager);
}
@Override
public void addView(View view) {
getLayoutManager().addDisappearingView(view, 0);
// Log.i("added disappearing view, position = " + getLayoutManager().getPosition(view));
// Log.d("name = " + ((TextView)view.findViewById(R.id.tvName)).getText().toString());
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/DisappearingViewAtStartPlacer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 157 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
class RealPlacerFactory implements IPlacerFactory {
private RecyclerView.LayoutManager layoutManager;
RealPlacerFactory(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
@Override
public IPlacer getAtStartPlacer() {
return new RealAtStartPlacer(layoutManager);
}
@Override
public IPlacer getAtEndPlacer() {
return new RealAtEndPlacer(layoutManager);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/RealPlacerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 121 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
class DisappearingPlacerFactory implements IPlacerFactory {
private RecyclerView.LayoutManager layoutManager;
DisappearingPlacerFactory(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
@Override
public IPlacer getAtStartPlacer() {
return new DisappearingViewAtStartPlacer(layoutManager);
}
@Override
public IPlacer getAtEndPlacer() {
return new DisappearingViewAtEndPlacer(layoutManager);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/DisappearingPlacerFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 131 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
import android.view.View;
class RealAtStartPlacer extends AbstractPlacer implements IPlacer {
RealAtStartPlacer(RecyclerView.LayoutManager layoutManager) {
super(layoutManager);
}
@Override
public void addView(View view) {
//mark that we add view at beginning of children
getLayoutManager().addView(view, 0);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/RealAtStartPlacer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 102 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
abstract class AbstractPlacer implements IPlacer {
private RecyclerView.LayoutManager layoutManager;
AbstractPlacer(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
public RecyclerView.LayoutManager getLayoutManager() {
return layoutManager;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/AbstractPlacer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 76 |
```java
package com.beloo.widget.chipslayoutmanager.layouter.placer;
import android.support.v7.widget.RecyclerView;
import android.view.View;
class RealAtEndPlacer extends AbstractPlacer implements IPlacer {
RealAtEndPlacer(RecyclerView.LayoutManager layoutManager) {
super(layoutManager);
}
@Override
public void addView(View view) {
getLayoutManager().addView(view);
// Log.i("added view, position = " + getLayoutManager().getPosition(view));
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/layouter/placer/RealAtEndPlacer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 105 |
```java
package com.beloo.widget.chipslayoutmanager.cache;
import android.support.v7.widget.RecyclerView;
public class ViewCacheFactory {
private RecyclerView.LayoutManager layoutManager;
public ViewCacheFactory(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
}
public IViewCacheStorage createCacheStorage() {
return new ViewCacheStorage(layoutManager);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/cache/ViewCacheFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 77 |
```java
package com.beloo.widget.chipslayoutmanager.cache;
import android.graphics.Rect;
import android.os.Parcelable;
import android.support.annotation.Nullable;
import android.util.Pair;
import android.view.View;
import java.util.List;
public interface IViewCacheStorage {
boolean isPositionEndsRow(int position);
boolean isPositionStartsRow(int position);
void setCachingEnabled(boolean isEnabled);
boolean isCachingEnabled();
int getStartOfRow(int endRow);
void storeRow(List<Pair<Rect, View>> row);
boolean isInCache(int position);
/** purge whole cache*/
void purge();
/** all cache to selected position will be purged
* @param position the end position, exclusive */
void purgeCacheToPosition(int position);
@Nullable
/** @return null if cache empty*/
Integer getLastCachePosition();
boolean isCacheEmpty();
/** all cache from selected position will be purged
* @param position the start position, inclusive */
void purgeCacheFromPosition(int position);
/** onSaveInstanceState cache storage content to {@link Parcelable}*/
Parcelable onSaveInstanceState();
void onRestoreInstanceState(@Nullable Parcelable parcelable);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/cache/IViewCacheStorage.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 244 |
```java
package com.beloo.widget.chipslayoutmanager.cache;
import android.os.Parcel;
import android.os.Parcelable;
import java.util.LinkedList;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;
public final class CacheParcelableContainer implements Parcelable {
private NavigableSet<Integer> startsRow = new TreeSet<>();
private NavigableSet<Integer> endsRow = new TreeSet<>();
CacheParcelableContainer(NavigableSet<Integer> startsRow, NavigableSet<Integer> endsRow) {
this.startsRow = startsRow;
this.endsRow = endsRow;
}
private CacheParcelableContainer(Parcel in) {
List<Integer> startsRowList = new LinkedList<>();
List<Integer> endsRowList = new LinkedList<>();
in.readList(startsRowList, Integer.class.getClassLoader());
in.readList(endsRowList, Integer.class.getClassLoader());
startsRow = new TreeSet<>(startsRowList);
endsRow = new TreeSet<>(endsRowList);
}
@Override
public void writeToParcel(Parcel parcel, int i) {
List<Integer> startRowList = new LinkedList<>(startsRow);
List<Integer> endRowList = new LinkedList<>(endsRow);
parcel.writeList(startRowList);
parcel.writeList(endRowList);
}
NavigableSet<Integer> getStartsRow() {
return startsRow;
}
NavigableSet<Integer> getEndsRow() {
return endsRow;
}
@Override
public int describeContents() {
return 0;
}
public static final Creator<CacheParcelableContainer> CREATOR = new Creator<CacheParcelableContainer>() {
@Override
public CacheParcelableContainer createFromParcel(Parcel in) {
return new CacheParcelableContainer(in);
}
@Override
public CacheParcelableContainer[] newArray(int size) {
return new CacheParcelableContainer[size];
}
};
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/cache/CacheParcelableContainer.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 403 |
```java
package com.beloo.widget.chipslayoutmanager.anchor;
import android.graphics.Rect;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.ChildViewsIterable;
import com.beloo.widget.chipslayoutmanager.layouter.ICanvas;
public class ColumnsAnchorFactory extends AbstractAnchorFactory {
private ChildViewsIterable childViews;
public ColumnsAnchorFactory(RecyclerView.LayoutManager lm, ICanvas canvas) {
super(lm, canvas);
childViews = new ChildViewsIterable(lm);
}
/** get the closest views to left border. The highest view will be picked from it. */
@Override
public AnchorViewState getAnchor() {
AnchorViewState minPosView = AnchorViewState.getNotFoundState();
int minPosition = Integer.MAX_VALUE;
int minLeft = Integer.MAX_VALUE;
int maxRight = Integer.MIN_VALUE;
for (View view : childViews) {
AnchorViewState anchorViewState = createAnchorState(view);
int pos = lm.getPosition(view);
int left = lm.getDecoratedLeft(view);
int right = lm.getDecoratedRight(view);
Rect viewRect = new Rect(anchorViewState.getAnchorViewRect());
if (getCanvas().isInside(viewRect) && !anchorViewState.isRemoving()) {
if (minPosition > pos) {
minPosition = pos;
minPosView = anchorViewState;
}
if (minLeft > left) {
minLeft = left;
maxRight = right;
} else if (minLeft == left) {
maxRight = Math.max(maxRight, right);
}
}
}
if (!minPosView.isNotFoundState()) {
minPosView.getAnchorViewRect().left = minLeft;
minPosView.getAnchorViewRect().right = maxRight;
minPosView.setPosition(minPosition);
}
return minPosView;
}
@Override
public void resetRowCoordinates(AnchorViewState anchorView) {
if (!anchorView.isNotFoundState()) {
Rect rect = anchorView.getAnchorViewRect();
rect.top = getCanvas().getCanvasTopBorder();
rect.bottom = getCanvas().getCanvasBottomBorder();
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/anchor/ColumnsAnchorFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 465 |
```java
package com.beloo.widget.chipslayoutmanager.cache;
import android.graphics.Rect;
import android.os.Parcelable;
import android.support.annotation.Nullable;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.util.Pair;
import android.view.View;
import java.util.Iterator;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;
class ViewCacheStorage implements IViewCacheStorage {
private static final String TAG = ViewCacheStorage.class.getSimpleName();
private static final int SIZE_MAX_CACHE = 1000;
private RecyclerView.LayoutManager layoutManager;
private NavigableSet<Integer> startsRow = new TreeSet<>();
private NavigableSet<Integer> endsRow = new TreeSet<>();
private int maxCacheSize = SIZE_MAX_CACHE;
private boolean isCachingEnabled;
ViewCacheStorage(RecyclerView.LayoutManager layoutManager) {
this.layoutManager = layoutManager;
isCachingEnabled = true;
}
public void setMaxCacheSize(int maxCacheSize) {
this.maxCacheSize = maxCacheSize;
}
@Override
public boolean isCachingEnabled() {
return isCachingEnabled;
}
@Override
public int getStartOfRow(int positionInRow) {
Integer integer = startsRow.floor(positionInRow);
if (integer == null) {
integer = positionInRow;
}
return integer;
}
@Override
public boolean isPositionEndsRow(int position) {
return endsRow.contains(position);
}
@Override
public boolean isPositionStartsRow(int position) {
return startsRow.contains(position);
}
@Override
public void setCachingEnabled(boolean isEnabled) {
if (isCachingEnabled == isEnabled) return;
Log.i(TAG, isEnabled ? "caching enabled" : "caching disabled");
isCachingEnabled = isEnabled;
}
//todo test max size cache reached
private void checkCacheSizeReached() {
if (startsRow.size() > maxCacheSize) {
startsRow.remove(startsRow.first());
}
if (endsRow.size() > maxCacheSize) {
endsRow.remove(endsRow.first());
}
}
@Override
public void storeRow(List<Pair<Rect, View>> row) {
if (isCachingEnabled && !row.isEmpty()) {
Pair<Rect, View> firstPair = row.get(0);
Pair<Rect, View> secondPair = row.get(row.size()-1);
int startPosition = layoutManager.getPosition(firstPair.second);
int endPosition = layoutManager.getPosition(secondPair.second);
checkCacheSizeReached();
startsRow.add(startPosition);
endsRow.add(endPosition);
}
}
@Override
public boolean isInCache(int position) {
return startsRow.ceiling(position) != null || endsRow.ceiling(position) != null;
}
@Override
public void purge() {
startsRow.clear();
endsRow.clear();
}
@Override
public void purgeCacheToPosition(int position) {
if (isCacheEmpty()) return;
Log.d(TAG, "cache purged to position " + position);
Iterator<Integer> removeIterator = startsRow.headSet(position).iterator();
while (removeIterator.hasNext()) {
removeIterator.next();
removeIterator.remove();
}
removeIterator = endsRow.headSet(position).iterator();
while (removeIterator.hasNext()) {
removeIterator.next();
removeIterator.remove();
}
}
@Override
public Integer getLastCachePosition() {
if (isCacheEmpty()) return null;
return endsRow.last();
}
@Override
public boolean isCacheEmpty() {
return endsRow.isEmpty();
}
@Override
public void purgeCacheFromPosition(int position) {
if (isCacheEmpty()) return;
Iterator<Integer> removeIterator = startsRow.tailSet(position, true).iterator();
while (removeIterator.hasNext()) {
removeIterator.next();
removeIterator.remove();
}
Integer previous = startsRow.lower(position);
previous = previous == null? position : previous;
//we should also remove previous end row cache to guarantee consistency
removeIterator = endsRow.tailSet(previous, true).iterator();
while (removeIterator.hasNext()) {
removeIterator.next();
removeIterator.remove();
}
}
@Override
public Parcelable onSaveInstanceState() {
return new CacheParcelableContainer(startsRow, endsRow);
}
public void onRestoreInstanceState(@Nullable Parcelable parcelable) {
if (parcelable == null) return;
if (!(parcelable instanceof CacheParcelableContainer)) throw new IllegalStateException("wrong parcelable passed");
CacheParcelableContainer container = (CacheParcelableContainer) parcelable;
startsRow = container.getStartsRow();
endsRow = container.getEndsRow();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/cache/ViewCacheStorage.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 1,022 |
```java
package com.beloo.widget.chipslayoutmanager.anchor;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.layouter.ICanvas;
abstract class AbstractAnchorFactory implements IAnchorFactory {
RecyclerView.LayoutManager lm;
private ICanvas canvas;
AbstractAnchorFactory(RecyclerView.LayoutManager lm, ICanvas canvas) {
this.lm = lm;
this.canvas = canvas;
}
ICanvas getCanvas() {
return canvas;
}
AnchorViewState createAnchorState(View view) {
return new AnchorViewState(lm.getPosition(view), canvas.getViewRect(view));
}
@Override
public AnchorViewState createNotFound() {
return AnchorViewState.getNotFoundState();
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/anchor/AbstractAnchorFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 154 |
```java
package com.beloo.widget.chipslayoutmanager.anchor;
public interface IAnchorFactory {
/** find the view in a higher row which is closest to the left border*/
AnchorViewState getAnchor();
AnchorViewState createNotFound();
/** modify anchorView state according to pre-layout state */
void resetRowCoordinates(AnchorViewState anchorView);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/anchor/IAnchorFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 71 |
```java
package com.beloo.widget.chipslayoutmanager.anchor;
import android.graphics.Rect;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import java.util.Locale;
/**
* represents View, which is highest visible left view
*/
public class AnchorViewState implements Parcelable {
private Integer position = 0;
private Rect anchorViewRect;
private AnchorViewState() {
}
static AnchorViewState getNotFoundState() {
return new AnchorViewState();
}
AnchorViewState(int position, @NonNull Rect anchorViewRect) {
this.position = position;
this.anchorViewRect = anchorViewRect;
}
public boolean isNotFoundState() {
return anchorViewRect == null;
}
public Integer getPosition() {
return position;
}
public void setPosition(Integer position) {
this.position = position;
}
public Rect getAnchorViewRect() {
return anchorViewRect;
}
public void setAnchorViewRect(Rect anchorViewRect) {
this.anchorViewRect = anchorViewRect;
}
public boolean isRemoving() {
return getPosition() == -1;
}
//parcelable logic below
private AnchorViewState(Parcel parcel) {
int parcelPosition = parcel.readInt();
position = parcelPosition == -1? null : parcelPosition;
anchorViewRect = parcel.readParcelable(AnchorViewState.class.getClassLoader());
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel parcel, int i) {
parcel.writeInt(position == null? -1 : position);
parcel.writeParcelable(anchorViewRect, 0);
}
public static final Parcelable.Creator<AnchorViewState> CREATOR = new Parcelable.Creator<AnchorViewState>() {
// unpack Object from Parcel
public AnchorViewState createFromParcel(Parcel in) {
return new AnchorViewState(in);
}
public AnchorViewState[] newArray(int size) {
return new AnchorViewState[size];
}
};
@Override
public String toString() {
return String.format(Locale.getDefault(), "AnchorState. Position = %d, Rect = %s", position, String.valueOf(anchorViewRect));
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/anchor/AnchorViewState.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 459 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import com.beloo.widget.chipslayoutmanager.RowStrategy;
public interface IRowStrategyFactory {
IRowStrategy createRowStrategy(@RowStrategy int rowStrategy);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/IRowStrategyFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 46 |
```java
package com.beloo.widget.chipslayoutmanager.anchor;
import android.graphics.Rect;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import com.beloo.widget.chipslayoutmanager.ChildViewsIterable;
import com.beloo.widget.chipslayoutmanager.layouter.ICanvas;
public class RowsAnchorFactory extends AbstractAnchorFactory {
private ChildViewsIterable childViews;
public RowsAnchorFactory(RecyclerView.LayoutManager lm, ICanvas canvas) {
super(lm, canvas);
childViews = new ChildViewsIterable(lm);
}
/** get the highest views in layout. The closest to left border view will be picked from it. */
@Override
public AnchorViewState getAnchor() {
AnchorViewState minPosView = AnchorViewState.getNotFoundState();
int minPosition = Integer.MAX_VALUE;
int minTop = Integer.MAX_VALUE;
for (View view : childViews) {
AnchorViewState anchorViewState = createAnchorState(view);
int pos = lm.getPosition(view);
int top = lm.getDecoratedTop(view);
Rect viewRect = new Rect(anchorViewState.getAnchorViewRect());
if (getCanvas().isInside(viewRect) && !anchorViewState.isRemoving()) {
if (minPosition > pos) {
minPosition = pos;
minPosView = anchorViewState;
}
if (minTop > top) {
minTop = top;
}
}
}
if (!minPosView.isNotFoundState()) {
minPosView.getAnchorViewRect().top = minTop;
/* we don't need bottom coordinate for layouter
also this helps to normalize row properly when anchor deleted and was the biggest view in a row
*/
minPosView.setPosition(minPosition);
}
return minPosView;
}
@Override
public void resetRowCoordinates(AnchorViewState anchorView) {
if (!anchorView.isNotFoundState()) {
Rect rect = anchorView.getAnchorViewRect();
rect.left = getCanvas().getCanvasLeftBorder();
rect.right = getCanvas().getCanvasRightBorder();
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/anchor/RowsAnchorFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 439 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.graphics.Rect;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
class RTLRowFillStrategy implements IRowStrategy {
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
int difference = GravityUtil.getHorizontalDifference(abstractLayouter) / abstractLayouter.getRowSize();
int offsetDifference = difference;
for (Item item : row) {
Rect childRect = item.getViewRect();
if (childRect.right == abstractLayouter.getCanvasRightBorder()) {
//right view of row
int rightDif = abstractLayouter.getCanvasRightBorder() - childRect.right;
//press view to right border
childRect.left += rightDif;
childRect.right = abstractLayouter.getCanvasRightBorder();
childRect.left -= offsetDifference;
continue;
}
childRect.right -= offsetDifference;
offsetDifference += difference;
childRect.left -= offsetDifference;
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/RTLRowFillStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 240 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.support.annotation.NonNull;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
class StrategyDecorator implements IRowStrategy {
@NonNull
private IRowStrategy rowStrategy;
StrategyDecorator(@NonNull IRowStrategy rowStrategy) {
this.rowStrategy = rowStrategy;
}
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
rowStrategy.applyStrategy(abstractLayouter, row);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/StrategyDecorator.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 130 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
public interface IRowStrategy {
void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row);
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/IRowStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 68 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.graphics.Rect;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
class LTRRowFillStrategy implements IRowStrategy {
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
int difference = GravityUtil.getHorizontalDifference(abstractLayouter) / abstractLayouter.getRowSize();
int offsetDifference = difference;
for (Item item : row) {
Rect childRect = item.getViewRect();
if (childRect.left == abstractLayouter.getCanvasLeftBorder()) {
//left view of row
int leftDif = childRect.left - abstractLayouter.getCanvasLeftBorder();
//press view to left border
childRect.left = abstractLayouter.getCanvasLeftBorder();
childRect.right -= leftDif;
//increase view width from right
childRect.right += offsetDifference;
continue;
}
childRect.left += offsetDifference;
offsetDifference += difference;
childRect.right += offsetDifference;
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/LTRRowFillStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 248 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.graphics.Rect;
class BottomGravityModifier implements IGravityModifier {
@Override
public Rect modifyChildRect(int minStart, int maxEnd, Rect childRect) {
if (childRect.top < minStart) {
throw new IllegalArgumentException("top point of input rect can't be lower than minTop");
}
if (childRect.bottom > maxEnd) {
throw new IllegalArgumentException("bottom point of input rect can't be bigger than maxTop");
}
Rect modified = new Rect(childRect);
if (modified.bottom < maxEnd) {
modified.top += maxEnd - modified.bottom;
modified.bottom = maxEnd;
}
return modified;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/BottomGravityModifier.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 156 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import com.beloo.widget.chipslayoutmanager.ChipsLayoutManager;
import com.beloo.widget.chipslayoutmanager.RowStrategy;
public class LTRRowStrategyFactory implements IRowStrategyFactory {
@Override
public IRowStrategy createRowStrategy(@RowStrategy int rowStrategy) {
switch (rowStrategy) {
case ChipsLayoutManager.STRATEGY_CENTER:
return new LTRRowFillSpaceCenterStrategy();
case ChipsLayoutManager.STRATEGY_CENTER_DENSE:
return new LTRRowFillSpaceCenterDenseStrategy();
case ChipsLayoutManager.STRATEGY_FILL_SPACE:
return new LTRRowFillSpaceStrategy();
case ChipsLayoutManager.STRATEGY_FILL_VIEW:
return new LTRRowFillStrategy();
case ChipsLayoutManager.STRATEGY_DEFAULT:
default:
return new EmptyRowStrategy();
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/LTRRowStrategyFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 184 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.graphics.Rect;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
class ColumnFillStrategy implements IRowStrategy {
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
int difference = GravityUtil.getVerticalDifference(abstractLayouter) / abstractLayouter.getRowSize();
int offsetDifference = difference;
for (Item item : row) {
Rect childRect = item.getViewRect();
if (childRect.top == abstractLayouter.getCanvasTopBorder()) {
//highest view of row
int topDif = childRect.top - abstractLayouter.getCanvasTopBorder();
//press view to top border
childRect.top = abstractLayouter.getCanvasTopBorder();
childRect.bottom -= topDif;
//increase view height from bottom
childRect.bottom += offsetDifference;
continue;
}
childRect.top += offsetDifference;
offsetDifference += difference;
childRect.bottom += offsetDifference;
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/ColumnFillStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 246 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
class EmptyRowStrategy implements IRowStrategy {
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
//do nothing
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/EmptyRowStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 84 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.graphics.Rect;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
class RTLRowFillSpaceCenterDenseStrategy implements IRowStrategy {
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
int difference = GravityUtil.getHorizontalDifference(abstractLayouter) / 2;
for (Item item : row) {
Rect childRect = item.getViewRect();
childRect.left -= difference;
childRect.right -= difference;
}
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/RTLRowFillSpaceCenterDenseStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 141 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.support.annotation.NonNull;
import com.beloo.widget.chipslayoutmanager.layouter.AbstractLayouter;
import com.beloo.widget.chipslayoutmanager.layouter.Item;
import java.util.List;
public class SkipLastRowStrategy extends StrategyDecorator {
private boolean skipLastRow;
public SkipLastRowStrategy(@NonNull IRowStrategy rowStrategy, boolean skipLastRow) {
super(rowStrategy);
this.skipLastRow = skipLastRow;
}
@Override
public void applyStrategy(AbstractLayouter abstractLayouter, List<Item> row) {
//if !canNotBePlacedInCurrentRow and apply strategy called probably it is last row
//so skip applying strategy
if (skipLastRow && !abstractLayouter.isRowCompleted()) return;
super.applyStrategy(abstractLayouter, row);
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/SkipLastRowStrategy.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 187 |
```java
package com.beloo.widget.chipslayoutmanager.gravity;
import android.util.SparseArray;
import android.view.Gravity;
import com.beloo.widget.chipslayoutmanager.SpanLayoutChildGravity;
public class RowGravityModifiersFactory implements IGravityModifiersFactory {
private SparseArray<IGravityModifier> gravityModifierMap;
public RowGravityModifiersFactory() {
gravityModifierMap = new SparseArray<>();
CenterInRowGravityModifier centerInRowGravityModifier = new CenterInRowGravityModifier();
TopGravityModifier topGravityModifier = new TopGravityModifier();
BottomGravityModifier bottomGravityModifier = new BottomGravityModifier();
gravityModifierMap.put(Gravity.TOP, topGravityModifier);
gravityModifierMap.put(Gravity.BOTTOM, bottomGravityModifier);
gravityModifierMap.put(Gravity.CENTER, centerInRowGravityModifier);
gravityModifierMap.put(Gravity.CENTER_VERTICAL, centerInRowGravityModifier);
}
public IGravityModifier getGravityModifier(@SpanLayoutChildGravity int gravity) {
IGravityModifier gravityModifier = gravityModifierMap.get(gravity);
if (gravityModifier == null) {
gravityModifier = gravityModifierMap.get(Gravity.CENTER_VERTICAL);
}
return gravityModifier;
}
}
``` | /content/code_sandbox/ChipsLayoutManager/src/main/java/com/beloo/widget/chipslayoutmanager/gravity/RowGravityModifiersFactory.java | java | 2016-08-03T19:23:43 | 2024-08-12T07:26:54 | ChipsLayoutManager | BelooS/ChipsLayoutManager | 3,247 | 243 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.