Java OrientationHelper.HORIZONTAL属性代码示例

@Override
public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
    int spanCount = ((GridLayoutManager) parent.getLayoutManager()).getSpanCount();
    int orientation = ((GridLayoutManager)parent.getLayoutManager()).getOrientation();
    int position = parent.getChildLayoutPosition(view);
    if(orientation == OrientationHelper.VERTICAL && (position + 1) % spanCount == 0) {
        outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
        return;
    }

    if(orientation == OrientationHelper.HORIZONTAL && (position + 1) % spanCount == 0) {
        outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
        return;
    }

    outRect.set(0, 0, mDivider.getIntrinsicWidth(), mDivider.getIntrinsicHeight());
}
 

@Override
public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
    //Fix for bug with bottom selection bar and different month item height in horizontal mode (different count of weeks)
    View view = rvMonths.getLayoutManager().findViewByPosition(getFirstVisiblePosition(rvMonths.getLayoutManager()));
    if (view != null) {
        view.requestLayout();
    }

    if (getCalendarOrientation() == OrientationHelper.HORIZONTAL) {
        multipleSelectionBarAdapter.notifyDataSetChanged();

        //Hide navigation buttons
        boolean show = newState != RecyclerView.SCROLL_STATE_DRAGGING;
        ivPrevious.setVisibility(show ? View.VISIBLE : View.GONE);
        ivNext.setVisibility(show ? View.VISIBLE : View.GONE);
    }

    super.onScrollStateChanged(recyclerView, newState);
}
 

@Override
public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
    if(OrientationHelper.HORIZONTAL==orientation){
        outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
    }else {
        outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
    }
}
 

/**
 * Finds the layout orientation of the RecyclerView, no matter which LayoutManager is in use.
 *
 * @param layoutManager the LayoutManager instance in use by the RV
 * @return one of {@link OrientationHelper#HORIZONTAL}, {@link OrientationHelper#VERTICAL}
 */
public static int getOrientation(RecyclerView.LayoutManager layoutManager) {
	if (layoutManager instanceof LinearLayoutManager) {
		return ((LinearLayoutManager) layoutManager).getOrientation();
	} else if (layoutManager instanceof StaggeredGridLayoutManager) {
		return ((StaggeredGridLayoutManager) layoutManager).getOrientation();
	}
	return OrientationHelper.HORIZONTAL;
}
 

/**
 * Controls the direction in which smoothScroll looks for your view
 *
 * @return the vector position
 */
@Override
public PointF computeScrollVectorForPosition(int targetPosition) {
	final int firstChildPos = Utils.findFirstCompletelyVisibleItemPosition(layoutManager);
	final int direction = targetPosition < firstChildPos ? -1 : 1;

	if (Utils.getOrientation(layoutManager) == OrientationHelper.HORIZONTAL) {
		vectorPosition.set(direction, 0);
		return vectorPosition;
	} else {
		vectorPosition.set(0, direction);
		return vectorPosition;
	}
}
 

@Override
public Component createComponent(ComponentContext c) {
  final RecyclerBinder imageRecyclerBinder =
      new RecyclerBinder(c, 4.0f, new LinearLayoutInfo(c, OrientationHelper.HORIZONTAL, false));

  for (String image : images) {
    ComponentInfo.Builder imageComponentInfoBuilder = ComponentInfo.create();
    imageComponentInfoBuilder.component(
        PicassoSingleImageComponent.create(c).image(image).fit(true).build());
    imageRecyclerBinder.insertItemAt(imageRecyclerBinder.getItemCount(),
        imageComponentInfoBuilder.build());
  }

  return FeedItemCard.create(c).artist(this).binder(imageRecyclerBinder).build();
}
 

@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
    int layoutResId = R.layout.item_one;
    RecyclerView.LayoutManager layoutManager = ((RecyclerView) parent).getLayoutManager();
    if (layoutManager instanceof LinearLayoutManager) {
        LinearLayoutManager manager = (LinearLayoutManager) layoutManager;
        if (manager.getOrientation() == OrientationHelper.HORIZONTAL) {
            layoutResId = R.layout.item_two;
        }
    }
    View view = mInflater.inflate(layoutResId, parent, false);
    return new TextViewHolder(view);
}
 

/**
 * Defines do we need to show range of selected days in bottom selection bar
 *
 * @return
 */
private boolean needToShowSelectedDaysRange() {
    if (getCalendarOrientation() == OrientationHelper.HORIZONTAL && getSelectionType() == SelectionType.RANGE) {
        if (selectionManager instanceof RangeSelectionManager) {
            if (((RangeSelectionManager) selectionManager).getDays() != null) {
                return true;
            }
        }
    }
    return false;
}
 

public UIDivider(Context context, int orientation, int dividerColor, Drawable dividerDrawable,
                 int dividerWidth,int marginLeft,int marginRight) {
    if (orientation != OrientationHelper.HORIZONTAL && orientation !=OrientationHelper.VERTICAL){
        throw new IllegalArgumentException("分割线 方向出错");
    }
    if (dividerWidth <0)
        throw new IllegalArgumentException("分割线 尺寸出错");
    mOrientation = orientation;
    mDividerColor = dividerColor;
    mDividerDrawable = dividerDrawable;
    mDividerWidth = dividerWidth;
    mMarginLeft = marginLeft;
    mMarginRight = marginRight;
    initPaint();
}
 

@Override
public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
   if (mOrientation == OrientationHelper.HORIZONTAL){
       drawHorizontal(c,parent);
   }else {
       drawVertical(c,parent); 
   }
}
 

@Override
public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
    // 绘制间隔，每一个item，绘制右边和下方间隔样式
    int childCount = parent.getChildCount();
    int spanCount = ((GridLayoutManager)parent.getLayoutManager()).getSpanCount();
    int orientation = ((GridLayoutManager)parent.getLayoutManager()).getOrientation();
    boolean isDrawHorizontalDivider = true;
    boolean isDrawVerticalDivider = true;
    int extra = childCount % spanCount;
    extra = extra == 0 ? spanCount : extra;
    for(int i = 0; i < childCount; i++) {
        isDrawVerticalDivider = true;
        isDrawHorizontalDivider = true;
        // 如果是竖直方向，最右边一列不绘制竖直方向的间隔
        if(orientation == OrientationHelper.VERTICAL && (i + 1) % spanCount == 0) {
            isDrawVerticalDivider = false;
        }

        // 如果是竖直方向，最后一行不绘制水平方向间隔
        if(orientation == OrientationHelper.VERTICAL && i >= childCount - extra) {
            isDrawHorizontalDivider = false;
        }

        // 如果是水平方向，最下面一行不绘制水平方向的间隔
        if(orientation == OrientationHelper.HORIZONTAL && (i + 1) % spanCount == 0) {
            isDrawHorizontalDivider = false;
        }

        // 如果是水平方向，最后一列不绘制竖直方向间隔
        if(orientation == OrientationHelper.HORIZONTAL && i >= childCount - extra) {
            isDrawVerticalDivider = false;
        }

        if(isDrawHorizontalDivider) {
            drawHorizontalDivider(c, parent, i);
        }

        if(isDrawVerticalDivider) {
            drawVerticalDivider(c, parent, i);
        }
    }
}
 

private void translateHeader() {
	// Sticky at zero offset (no translation)
	int headerOffsetX = 0, headerOffsetY = 0;
	// Get calculated elevation
	float elevation = mElevation;

	// Search for the position where the next header item is found and translate the new offset
	for (int i = 0; i < mRecyclerView.getChildCount(); i++) {
		final View nextChild = mRecyclerView.getChildAt(i);
		if (nextChild != null) {
			int adapterPos = mRecyclerView.getChildAdapterPosition(nextChild);
			int nextHeaderPosition = getStickyPosition(adapterPos);
			if (mHeaderPosition != nextHeaderPosition) {
				if (Utils.getOrientation(mRecyclerView.getLayoutManager()) == OrientationHelper.HORIZONTAL) {
					if (nextChild.getLeft() > 0) {
						int headerWidth = mStickyHolderLayout.getMeasuredWidth();
						int nextHeaderOffsetX = nextChild.getLeft() - headerWidth;
						headerOffsetX = Math.min(nextHeaderOffsetX, 0);
						// Early remove the elevation/shadow to match with the next view
						if (nextHeaderOffsetX < 5) elevation = 0f;
						if (headerOffsetX < 0) break;
					}
				} else {
					if (nextChild.getTop() > 0) {
						int headerHeight = mStickyHolderLayout.getMeasuredHeight();
						int nextHeaderOffsetY = nextChild.getTop() - headerHeight;
						headerOffsetY = Math.min(nextHeaderOffsetY, 0);
						// Early remove the elevation/shadow to match with the next view
						if (nextHeaderOffsetY < 5) elevation = 0f;
						if (headerOffsetY < 0) break;
					}
				}
			}
		}
	}
	// Apply the user elevation to the sticky container
	ViewCompat.setElevation(mStickyHolderLayout, elevation);
	// Apply translation (pushed up by another header)
	mStickyHolderLayout.setTranslationX(headerOffsetX);
	mStickyHolderLayout.setTranslationY(headerOffsetY);
	//Log.v(TAG, "TranslationX=" + headerOffsetX + " TranslationY=" + headerOffsetY);
}
 

private void renderContent(List<HomeSection> sections) {
    sRefresh.setRefreshing(false);
    ComponentInfo.Builder componentInfoBuilder;

    for (HomeSection section : sections) {

        componentInfoBuilder = ComponentInfo.create();

        if (section instanceof SingleBannerSection) {
            componentInfoBuilder
                    .component(
                            SingleBannerComponent
                                    .create(componentContext)
                                    .payload((SingleBannerSection) section)
                                    .key(((SingleBannerSection) section).title())
                                    .build()
                    );
        } else if (section instanceof TripleBannerSection) {

            componentInfoBuilder
                    .component(
                            TripleBannersComponent.create(componentContext)
                                    .payload((TripleBannerSection) section)
                                    .key(((TripleBannerSection) section).title())
                                    .build()
                    );
        } else if (section instanceof ProductSlideSection) {

            final RecyclerBinder productSlideBinder = new RecyclerBinder(componentContext, 4.0f,
                    new LinearLayoutInfo(this, OrientationHelper.HORIZONTAL, false));

            for (Product product : ((ProductSlideSection) section).products()) {
                componentInfoBuilder = ComponentInfo.create();
                componentInfoBuilder
                        .component(
                                ProductComponent.create(componentContext)
                                        .product(product)
                                        .key(product.id())
                                        .build()
                        );
                productSlideBinder.insertItemAt(productSlideBinder.getItemCount(), componentInfoBuilder.build());
            }

            componentInfoBuilder = ComponentInfo.create();
            componentInfoBuilder
                    .component(
                            ProductSlideComponent.create(componentContext)
                                    .title(((ProductSlideSection) section).title())
                                    .recyclerBinder(productSlideBinder)
                                    .key(((ProductSlideSection) section).title())
                                    .build()
                    );
        }
        recyclerBinder.insertItemAt(recyclerBinder.getItemCount(), componentInfoBuilder.build());
    }

    ltView.setComponent(
            HomeListComponent
                    .create(componentContext)
                    .binder(recyclerBinder)
                    .build()
    );
}
 

@Override
public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
    switch (newState) {
        case RecyclerView.SCROLL_STATE_DRAGGING:
            // distinct drag to improve accuracy, init mDraggingStart and mDraggingEnd here
            mDragging = true;
            final int[] range = AbstractLayoutManagerUtils.getVisibleRange(recyclerView);
            mDraggingStart = range[0];
            mDraggingEnd = range[1];
            break;
        case RecyclerView.SCROLL_STATE_SETTLING:
            mDragging = false;
            break;
        case RecyclerView.SCROLL_STATE_IDLE:
            mDragging = false;

            // perform final update on the range we have ever visited
            updateVisibleRange(recyclerView);
            AbstractLogUtils.e(this, "==>  visible range: [" + mDraggingStart + ", " + mDraggingEnd + "]");
            MeasurableRecyclerViewHelper.notifyMeasurableViewHolderDataRangeChanged(recyclerView, mDraggingStart, mDraggingEnd);

            // reset mDraggingStart and mDraggingEnd here
            mDraggingStart = RecyclerView.NO_POSITION;
            mDraggingEnd = RecyclerView.NO_POSITION;

            final boolean rtl = AbstractUIUtils.isRightToLeft(getRef());
            if (mRtl ^ rtl) {
                /*
                 * [ANDROID-1778]
                 *
                 * immediately flush the statistics if user change between a ltr and rtl language
                 * on the fly; do the check in here for better performance
                 */
                final List<IMeasurableViewHolder> holders =
                        MeasurableRecyclerViewHelper.getViewHolders(recyclerView, IMeasurableViewHolder.class);
                for (IMeasurableViewHolder holder : holders) {
                    holder.flush();
                }

                if (AbstractLayoutManagerUtils.getOrientation(recyclerView.getLayoutManager())
                        == OrientationHelper.HORIZONTAL) {
                    AbstractLayoutManagerUtils.setReverseLayout(recyclerView.getLayoutManager(), mRtl);
                }
            }
            break;
        default:
            break;
    }
}
 

public PrettyItemDecoration()
{
    this(OrientationHelper.HORIZONTAL);
}