Example usage for android.view View OVER_SCROLL_ALWAYS

List of usage examples for android.view View OVER_SCROLL_ALWAYS

Introduction

In this page you can find the example usage for android.view View OVER_SCROLL_ALWAYS.

Prototype

int OVER_SCROLL_ALWAYS

To view the source code for android.view View OVER_SCROLL_ALWAYS.

Click Source Link

Document

Always allow a user to over-scroll this view, provided it is a view that can scroll.

Usage

From source file:com.duy.pascal.ui.editor.view.CodeSuggestsEditText.java

public void showDropDown() throws Exception {
    if (mPopup.getAnchorView() == null) {
        if (mDropDownAnchorId != View.NO_ID) {
            mPopup.setAnchorView(getRootView().findViewById(mDropDownAnchorId));
        } else {//from www  . j a  v a2 s. co  m
            mPopup.setAnchorView(this);
        }
    }
    if (mAdapter.getCount() > 0) {
        mPopup.show();
        mPopup.getListView().setOverScrollMode(View.OVER_SCROLL_ALWAYS);
    }
}

From source file:ti.modules.titanium.ui.widget.TiUIScrollView.java

@Override
public void propertyChanged(String key, Object oldValue, Object newValue, KrollProxy proxy) {
    if (Log.isDebugModeEnabled()) {
        Log.d(TAG, "Property: " + key + " old: " + oldValue + " new: " + newValue, Log.DEBUG_MODE);
    }//from   w ww.j a v a 2s  . co  m

    if (key.equals(TiC.PROPERTY_CONTENT_OFFSET)) {
        setContentOffset(newValue);
        scrollTo(offsetX, offsetY, false);
    } else if (key.equals(TiC.PROPERTY_CAN_CANCEL_EVENTS)) {
        View view = this.scrollView;
        boolean canCancelEvents = TiConvert.toBoolean(newValue);
        if (view instanceof TiHorizontalScrollView) {
            ((TiHorizontalScrollView) view).getLayout().setCanCancelEvents(canCancelEvents);
        } else if (view instanceof TiVerticalScrollView) {
            ((TiVerticalScrollView) view).getLayout().setCanCancelEvents(canCancelEvents);
        }
    } else if (TiC.PROPERTY_SCROLLING_ENABLED.equals(key)) {
        setScrollingEnabled(newValue);
    } else if (TiC.PROPERTY_REFRESH_CONTROL.equals(key)) {
        View nativeView = getNativeView();
        if (nativeView instanceof TiSwipeRefreshLayout) {
            if (newValue == null) {
                RefreshControlProxy.unassignFrom((TiSwipeRefreshLayout) nativeView);
            } else if (newValue instanceof RefreshControlProxy) {
                ((RefreshControlProxy) newValue).assignTo((TiSwipeRefreshLayout) nativeView);
            } else {
                Log.e(TAG,
                        "Invalid value assigned to property '" + key + "'. Must be of type 'RefreshControl'.");
            }
        } else {
            Log.e(TAG, "ScrollView failed to obtain reference to 'TiSwipeRefreshLayout' object.");
        }
    } else if (TiC.PROPERTY_OVER_SCROLL_MODE.equals(key)) {
        if (this.scrollView != null) {
            this.scrollView.setOverScrollMode(TiConvert.toInt(newValue, View.OVER_SCROLL_ALWAYS));
        }
    }

    super.propertyChanged(key, oldValue, newValue, proxy);
}

From source file:ti.modules.titanium.ui.widget.TiUIScrollView.java

@Override
public void processProperties(KrollDict d) {
    boolean showHorizontalScrollBar = false;
    boolean showVerticalScrollBar = false;

    if (d.containsKey(TiC.PROPERTY_SCROLLING_ENABLED)) {
        setScrollingEnabled(d.get(TiC.PROPERTY_SCROLLING_ENABLED));
    }// ww  w.  jav a  2  s  . c om

    if (d.containsKey(TiC.PROPERTY_SHOW_HORIZONTAL_SCROLL_INDICATOR)) {
        showHorizontalScrollBar = TiConvert.toBoolean(d, TiC.PROPERTY_SHOW_HORIZONTAL_SCROLL_INDICATOR);
    }
    if (d.containsKey(TiC.PROPERTY_SHOW_VERTICAL_SCROLL_INDICATOR)) {
        showVerticalScrollBar = TiConvert.toBoolean(d, TiC.PROPERTY_SHOW_VERTICAL_SCROLL_INDICATOR);
    }

    if (showHorizontalScrollBar && showVerticalScrollBar) {
        Log.w(TAG, "Both scroll bars cannot be shown. Defaulting to vertical shown");
        showHorizontalScrollBar = false;
    }

    if (d.containsKey(TiC.PROPERTY_CONTENT_OFFSET)) {
        Object offset = d.get(TiC.PROPERTY_CONTENT_OFFSET);
        setContentOffset(offset);
    }

    int type = TYPE_VERTICAL;
    boolean deduced = false;

    if (d.containsKey(TiC.PROPERTY_WIDTH) && d.containsKey(TiC.PROPERTY_CONTENT_WIDTH)) {
        Object width = d.get(TiC.PROPERTY_WIDTH);
        Object contentWidth = d.get(TiC.PROPERTY_CONTENT_WIDTH);
        if (width.equals(contentWidth) || showVerticalScrollBar) {
            type = TYPE_VERTICAL;
            deduced = true;
        }
    }

    if (d.containsKey(TiC.PROPERTY_HEIGHT) && d.containsKey(TiC.PROPERTY_CONTENT_HEIGHT)) {
        Object height = d.get(TiC.PROPERTY_HEIGHT);
        Object contentHeight = d.get(TiC.PROPERTY_CONTENT_HEIGHT);
        if (height.equals(contentHeight) || showHorizontalScrollBar) {
            type = TYPE_HORIZONTAL;
            deduced = true;
        }
    }

    // android only property
    if (d.containsKey(TiC.PROPERTY_SCROLL_TYPE)) {
        Object scrollType = d.get(TiC.PROPERTY_SCROLL_TYPE);
        if (scrollType.equals(TiC.LAYOUT_VERTICAL)) {
            type = TYPE_VERTICAL;
        } else if (scrollType.equals(TiC.LAYOUT_HORIZONTAL)) {
            type = TYPE_HORIZONTAL;
        } else {
            Log.w(TAG, "scrollType value '" + TiConvert.toString(scrollType)
                    + "' is invalid. Only 'vertical' and 'horizontal' are supported.");
        }
    } else if (!deduced && type == TYPE_VERTICAL) {
        Log.w(TAG,
                "Scroll direction could not be determined based on the provided view properties. Default VERTICAL scroll direction being used. Use the 'scrollType' property to explicitly set the scrolling direction.");
    }

    // we create the view here since we now know the potential widget type
    LayoutArrangement arrangement = LayoutArrangement.DEFAULT;
    TiScrollViewLayout scrollViewLayout;
    if (d.containsKey(TiC.PROPERTY_LAYOUT) && d.getString(TiC.PROPERTY_LAYOUT).equals(TiC.LAYOUT_VERTICAL)) {
        arrangement = LayoutArrangement.VERTICAL;
    } else if (d.containsKey(TiC.PROPERTY_LAYOUT)
            && d.getString(TiC.PROPERTY_LAYOUT).equals(TiC.LAYOUT_HORIZONTAL)) {
        arrangement = LayoutArrangement.HORIZONTAL;
    }

    switch (type) {
    case TYPE_HORIZONTAL:
        Log.d(TAG, "creating horizontal scroll view", Log.DEBUG_MODE);
        this.scrollView = new TiHorizontalScrollView(getProxy().getActivity(), arrangement);
        scrollViewLayout = ((TiHorizontalScrollView) this.scrollView).getLayout();
        break;
    case TYPE_VERTICAL:
    default:
        Log.d(TAG, "creating vertical scroll view", Log.DEBUG_MODE);
        this.scrollView = new TiVerticalScrollView(getProxy().getActivity(), arrangement);
        scrollViewLayout = ((TiVerticalScrollView) this.scrollView).getLayout();
    }

    if (d.containsKey(TiC.PROPERTY_CAN_CANCEL_EVENTS)) {
        ((TiScrollViewLayout) scrollViewLayout)
                .setCanCancelEvents(TiConvert.toBoolean(d, TiC.PROPERTY_CAN_CANCEL_EVENTS));
    }

    boolean autoContentWidth = (scrollViewLayout
            .getContentProperty(TiC.PROPERTY_CONTENT_WIDTH) == TiScrollViewLayout.AUTO);
    boolean wrap = !autoContentWidth;
    if (d.containsKey(TiC.PROPERTY_HORIZONTAL_WRAP) && wrap) {
        wrap = TiConvert.toBoolean(d, TiC.PROPERTY_HORIZONTAL_WRAP, true);
    }
    scrollViewLayout.setEnableHorizontalWrap(wrap);

    if (d.containsKey(TiC.PROPERTY_OVER_SCROLL_MODE)) {
        if (Build.VERSION.SDK_INT >= 9) {
            this.scrollView.setOverScrollMode(
                    TiConvert.toInt(d.get(TiC.PROPERTY_OVER_SCROLL_MODE), View.OVER_SCROLL_ALWAYS));
        }
    }

    // Set up the swipe refresh layout container which wraps the scroll view.
    TiSwipeRefreshLayout swipeRefreshLayout = new TiSwipeRefreshLayout(getProxy().getActivity()) {
        @Override
        public void setClickable(boolean value) {
            View view = getLayout();
            if (view != null) {
                view.setClickable(value);
            }
        }

        @Override
        public void setLongClickable(boolean value) {
            View view = getLayout();
            if (view != null) {
                view.setLongClickable(value);
            }
        }

        @Override
        public void setOnClickListener(View.OnClickListener listener) {
            View view = getLayout();
            if (view != null) {
                view.setOnClickListener(listener);
            }
        }

        @Override
        public void setOnLongClickListener(View.OnLongClickListener listener) {
            View view = getLayout();
            if (view != null) {
                view.setOnLongClickListener(listener);
            }
        }
    };
    swipeRefreshLayout.setSwipeRefreshEnabled(false);
    swipeRefreshLayout.addView(this.scrollView);
    if (d.containsKey(TiC.PROPERTY_REFRESH_CONTROL)) {
        Object object = d.get(TiC.PROPERTY_REFRESH_CONTROL);
        if (object instanceof RefreshControlProxy) {
            ((RefreshControlProxy) object).assignTo(swipeRefreshLayout);
        }
    }
    setNativeView(swipeRefreshLayout);

    this.scrollView.setHorizontalScrollBarEnabled(showHorizontalScrollBar);
    this.scrollView.setVerticalScrollBarEnabled(showVerticalScrollBar);

    super.processProperties(d);
}

From source file:ti.modules.titanium.ui.widget.abslistview.TiAbsListView.java

@Override
public void propertySet(String key, Object newValue, Object oldValue, boolean changedProperty) {
    switch (key) {
    case TiC.PROPERTY_TEMPLATES:
        processTemplates((HashMap) newValue);
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        mProcessUpdateFlags |= TIFLAG_NEEDS_ADAPTER_CHANGE;
        //           if (changedProperty) {
        //                notifyDataSetChanged();
        //            }
        break;//from w  w w  .j  av  a  2 s. c o m
    case TiC.PROPERTY_SEARCH_TEXT:
        filterBy(TiConvert.toString(newValue));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_SEARCH_IGNORE_EXACT_MATCH:
        this.ignoreExactMatch = TiConvert.toBoolean(newValue, true);
        filterBy(TiConvert.toString(this.searchText));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_SEARCH_VIEW:
        setSearchView(newValue, true);
        break;
    case TiC.PROPERTY_SEARCH_VIEW_EXTERNAL:
        setSearchView(newValue, false);
        break;
    case TiC.PROPERTY_SCROLL_HIDES_KEYBOARD:
        this.hideKeyboardOnScroll = TiConvert.toBoolean(newValue, true);
        break;
    case TiC.PROPERTY_STICKY_HEADERS:
        listView.setAreHeadersSticky(TiConvert.toBoolean(newValue, false));
        break;
    case TiC.PROPERTY_CASE_INSENSITIVE_SEARCH:
        this.caseInsensitive = TiConvert.toBoolean(newValue, true);
        filterBy(TiConvert.toString(this.searchText));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_SEPARATOR_COLOR: {
        AbsListView internalListView = getInternalListView();
        if (internalListView instanceof ListView) {
            int dividerHeight = listView.getDividerHeight();
            ((ListView) internalListView).setDivider(new ColorDrawable(TiConvert.toColor(newValue)));
            ((ListView) internalListView).setDividerHeight(dividerHeight);
        }
        break;
    }
    case TiC.PROPERTY_FOOTER_DIVIDERS_ENABLED: {
        AbsListView internalListView = getInternalListView();
        if (internalListView instanceof ListView) {
            ((ListView) internalListView).setFooterDividersEnabled(TiConvert.toBoolean(newValue, false));
        }
        break;
    }
    case TiC.PROPERTY_HEADER_DIVIDERS_ENABLED: {
        AbsListView internalListView = getInternalListView();
        if (internalListView instanceof ListView) {
            ((ListView) internalListView).setHeaderDividersEnabled(TiConvert.toBoolean(newValue, false));
        }
        break;
    }
    case TiC.PROPERTY_SHOW_VERTICAL_SCROLL_INDICATOR:
        listView.setVerticalScrollBarEnabled(TiConvert.toBoolean(newValue, true));
        break;
    case TiC.PROPERTY_DEFAULT_ITEM_TEMPLATE:
        defaultTemplateBinding = TiConvert.toString(newValue);
        if (changedProperty) {
            notifyDataSetChanged();
        }
        break;
    case TiC.PROPERTY_SECTIONS:
        if (changedProperty) {
            mProcessUpdateFlags &= ~TIFLAG_NEEDS_DATASET;
            processSectionsAndNotify((Object[]) newValue);
        } else {
            //if user didn't append/modify/delete sections before this is called, we process sections
            //as usual. Otherwise, we process the preloadSections, which should also contain the section(s)
            //from this dictionary as well as other sections that user append/insert/deleted prior to this.
            AbsListViewProxy listProxy = (AbsListViewProxy) proxy;
            if (!listProxy.getPreload()) {
                processSections((Object[]) newValue);
            }
        }
        break;
    case TiC.PROPERTY_SEPARATOR_STYLE:
        Drawable drawable = listView.getDivider();
        listView.setDivider(drawable);
        listView.setDividerHeight(TiConvert.toInt(newValue, TiUITableView.SEPARATOR_SINGLE_LINE));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_OVER_SCROLL_MODE:
        //            if (Build.VERSION.SDK_INT >= 9) {
        listView.setOverScrollMode(TiConvert.toInt(newValue, View.OVER_SCROLL_ALWAYS));
        //            }
        break;
    case TiC.PROPERTY_HEADER_VIEW:
        setHeaderOrFooterView(newValue, true);
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_HEADER_TITLE:
        setHeaderTitle(TiConvert.toString(newValue));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_FOOTER_VIEW:
        setHeaderOrFooterView(newValue, false);
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_FOOTER_TITLE:
        //            if (footerView == null || footerView.getId() != HEADER_FOOTER_WRAP_ID) {
        //                if (footerView == null) {
        //                    footerView = inflater.inflate(headerFooterId, null);
        //                }
        setFooterTitle(TiConvert.toString(newValue));
        //            }
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_PULL_VIEW:
        ((RefreshableListView) listView).setHeaderPullView(setPullView(newValue));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    //      case TiC.PROPERTY_REFRESH_CONTROL:
    //         if (newValue instanceof RefreshControlProxy) {
    //            ((RefreshControlProxy)newValue).assignTo(this.wrapper);
    //         } else {
    //            RefreshControlProxy.unassignFrom(this.wrapper);
    //         }
    //            break;
    default:
        super.propertySet(key, newValue, oldValue, changedProperty);
        break;
    }
}

From source file:ti.modules.titanium.ui.widget.collectionview.TiCollectionView.java

@Override
public void propertySet(String key, Object newValue, Object oldValue, boolean changedProperty) {
    switch (key) {
    case "fastScroller":
        HashMap args = TiConvert.toHashMap(newValue);
        if (args != null) {
            mRecyclerView.setFastScrollEnabled(true);
            mRecyclerView.setVerticalScrollBarEnabled(false);
            // if (mFastScroller == null) {
            // mFastScroller = new DragScrollBar(getContext(),
            // mRecyclerView, false);
            // mFastScroller.addIndicator(new CustomIndicator(getContext()),
            // true);
            // mFastScroller.setZ(100);
            // mFastScroller.setBackgroundColor(Color.RED);;
            // }//from   ww  w.  ja va2  s  .c  o  m
            // mFastScroller.setVisibility(View.VISIBLE);
            if (args.containsKey("color")) {
                int color = TiConvert.toColor(args, "color");
                mRecyclerView.setThumbColor(color);
                mRecyclerView.setPopupBgColor(color);
            }
            // if (args.containsKey("barColor")) {
            // mFastScroller.setBarColour(TiConvert.toColor(args,
            // "barColor"));
            // }
            // if (args.containsKey("textColour")) {
            // mFastScroller.setTextColour(TiConvert.toColor(args,
            // "textColour"));
            // }
        } else {
            mRecyclerView.setFastScrollEnabled(false);
            mRecyclerView.setVerticalScrollBarEnabled(
                    TiConvert.toBoolean(proxy.getProperty(TiC.PROPERTY_SHOW_VERTICAL_SCROLL_INDICATOR), true));
            // if (mFastScroller != null) {
            // mFastScroller.setVisibility(View.GONE);
            // }
        }
        break;
    case TiC.PROPERTY_SCROLLING_ENABLED:
        layoutManager.setScrollEnabled(TiConvert.toBoolean(newValue));
        break;
    case "appearAnimation":
        if (newValue instanceof HashMap || newValue instanceof TiAnimation) {
            mAppearAnimation = newValue;
            mUseAppearAnimation = mAppearAnimation != null;
        } else {
            int id = TiConvert.toInt(newValue);
            if (id != 0) {
                mAppearAnimators = AnimatorInflater.loadAnimator(getProxy().getActivity(), id);
            } else {
                mAppearAnimators = null;
            }
            mUseAppearAnimation = mAppearAnimators != null;
        }

        break;
    case "useAppearAnimation":
        mUseAppearAnimation = TiConvert.toBoolean(newValue, false);
        break;
    case TiC.PROPERTY_COLUMN_WIDTH:
        mColumnsWidth = TiConvert.toTiDimension(newValue, TiDimension.TYPE_WIDTH);
        if (layoutManager != null) {
            if (mColumnsWidth != null) {
                layoutManager.setColumnWidth(mColumnsWidth.getAsPixels(mRecyclerView));
            }
        }

        break;
    case TiC.PROPERTY_NUM_COLUMNS:
        mColumnsWidth = null;
        mNumColumns = TiConvert.toInt(newValue);
        if (layoutManager != null) {
            layoutManager.setNumColumns(mNumColumns);
        }
        break;
    case TiC.PROPERTY_TEMPLATES:
        processTemplates((HashMap) newValue);
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        mProcessUpdateFlags |= TIFLAG_NEEDS_ADAPTER_CHANGE;
        // if (changedProperty) {
        // notifyDataSetChanged();
        // }
        break;
    case TiC.PROPERTY_SEARCH_TEXT:
        filterBy(TiConvert.toString(newValue));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_SEARCH_VIEW:
        setSearchView(newValue, true);
        break;
    case TiC.PROPERTY_SEARCH_VIEW_EXTERNAL:
        setSearchView(newValue, false);
        break;
    case TiC.PROPERTY_SCROLL_HIDES_KEYBOARD:
        this.hideKeyboardOnScroll = TiConvert.toBoolean(newValue, true);
        break;
    case TiC.PROPERTY_STICKY_HEADERS:
        boolean enabled = TiConvert.toBoolean(newValue, true);
        mAdapter.setStickySectionHeaders(enabled);
        break;
    case TiC.PROPERTY_CASE_INSENSITIVE_SEARCH:
        this.caseInsensitive = TiConvert.toBoolean(newValue, true);
        filterBy(TiConvert.toString(this.searchText));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_SEARCH_IGNORE_EXACT_MATCH:
        this.ignoreExactMatch = TiConvert.toBoolean(newValue, true);
        filterBy(TiConvert.toString(this.searchText));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    // case TiC.PROPERTY_SEPARATOR_COLOR:
    // {
    // AbsListView internalListView = getInternalListView();
    // if (internalListView instanceof ListView) {
    // int dividerHeight = listView.getDividerHeight();
    // ((ListView) internalListView).setDivider(new
    // ColorDrawable(TiConvert.toColor(newValue)));
    // ((ListView) internalListView).setDividerHeight(dividerHeight);
    // }
    // break;
    // }
    // case TiC.PROPERTY_FOOTER_DIVIDERS_ENABLED:
    // {
    // AbsListView internalListView = getInternalListView();
    // if (internalListView instanceof ListView) {
    // ((ListView)
    // internalListView).setFooterDividersEnabled(TiConvert.toBoolean(newValue,
    // false));
    // }
    // break;
    // }
    // case TiC.PROPERTY_HEADER_DIVIDERS_ENABLED:
    // {
    // AbsListView internalListView = getInternalListView();
    // if (internalListView instanceof ListView) {
    // ((ListView)
    // internalListView).setHeaderDividersEnabled(TiConvert.toBoolean(newValue,
    // false));
    // }
    // break;
    // }
    case TiC.PROPERTY_SHOW_VERTICAL_SCROLL_INDICATOR:
        mRecyclerView.setVerticalScrollBarEnabled(TiConvert.toBoolean(newValue, true));
        break;
    case TiC.PROPERTY_DEFAULT_ITEM_TEMPLATE:
        defaultTemplateBinding = TiConvert.toString(newValue);
        if (changedProperty) {
            notifyDataSetChanged();
        }
        break;
    case TiC.PROPERTY_SCROLL_DIRECTION: {
        final String direction = TiConvert.toString(newValue);
        if (direction.equalsIgnoreCase("horizontal")) {
            layoutManager.setOrientation(LinearLayoutManager.HORIZONTAL);
        } else {
            layoutManager.setOrientation(LinearLayoutManager.VERTICAL);
        }
        break;
    }
    case TiC.PROPERTY_SECTIONS:
        if (changedProperty) {
            // mProcessUpdateFlags &= ~TIFLAG_NEEDS_DATASET;
            processSectionsAndNotify((Object[]) newValue);
        } else {
            // if user didn't append/modify/delete sections before this is
            // called, we process sections
            // as usual. Otherwise, we process the preloadSections, which
            // should also contain the section(s)
            // from this dictionary as well as other sections that user
            // append/insert/deleted prior to this.
            AbsListViewProxy listProxy = (AbsListViewProxy) proxy;
            if (!listProxy.getPreload()) {
                // mProcessUpdateFlags &= ~TIFLAG_NEEDS_DATASET;
                processSectionsAndNotify((Object[]) newValue);
            }
        }
        break;
    case TiC.PROPERTY_SEPARATOR_STYLE:
        int height = (int) TiUIHelper.getInPixels(newValue);
        if (height == 0) {
            // if (mDividerDecoration != null) {
            // mRecyclerView.removeItemDecoration(mDividerDecoration);
            // }
            if (mDividerDecoration != null) {
                mDividerDecoration.setDividerHeight(height);
                mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
            }
        } else {
            if (mDividerDecoration == null) {
                mDividerDecoration = new DividerItemDecoration(getContext());
                mRecyclerView.addItemDecoration(mDividerDecoration);
            }
            mDividerDecoration.setDividerHeight(height);
            mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        }
        break;
    case TiC.PROPERTY_OVER_SCROLL_MODE:
        // if (Build.VERSION.SDK_INT >= 9) {
        mRecyclerView.setOverScrollMode(TiConvert.toInt(newValue, View.OVER_SCROLL_ALWAYS));
        // }
        break;
    case TiC.PROPERTY_HEADER_VIEW:
        setHeaderOrFooterView(newValue, true);
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_HEADER_TITLE:
        setHeaderTitle(TiConvert.toString(newValue));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_FOOTER_VIEW:
        setHeaderOrFooterView(newValue, false);
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case TiC.PROPERTY_FOOTER_TITLE:
        setFooterTitle(TiConvert.toString(newValue));
        mProcessUpdateFlags |= TIFLAG_NEEDS_DATASET;
        break;
    case "reverseDrawingOrder":
        boolean reversed = TiConvert.toBoolean(newValue, false);
        if (reversed) {
            mRecyclerView.setChildDrawingOrderCallback(new RecyclerView.ChildDrawingOrderCallback() {
                @Override
                public int onGetChildDrawingOrder(int childCount, int i) {
                    return childCount - i - 1;
                }
            });
        } else {
            mRecyclerView.setChildDrawingOrderCallback(null);
        }

        break;
    default:
        super.propertySet(key, newValue, oldValue, changedProperty);
        break;
    }
}

From source file:com.android.internal.widget.ViewPager.java

@Override
public void draw(Canvas canvas) {
    super.draw(canvas);
    boolean needsInvalidate = false;

    final int overScrollMode = getOverScrollMode();
    if (overScrollMode == View.OVER_SCROLL_ALWAYS || (overScrollMode == View.OVER_SCROLL_IF_CONTENT_SCROLLS
            && mAdapter != null && mAdapter.getCount() > 1)) {
        if (!mLeftEdge.isFinished()) {
            final int restoreCount = canvas.save();
            final int height = getHeight() - getPaddingTop() - getPaddingBottom();
            final int width = getWidth();

            canvas.rotate(270);/*w w w .j ava2s.  c  o  m*/
            canvas.translate(-height + getPaddingTop(), mFirstOffset * width);
            mLeftEdge.setSize(height, width);
            needsInvalidate |= mLeftEdge.draw(canvas);
            canvas.restoreToCount(restoreCount);
        }
        if (!mRightEdge.isFinished()) {
            final int restoreCount = canvas.save();
            final int width = getWidth();
            final int height = getHeight() - getPaddingTop() - getPaddingBottom();

            canvas.rotate(90);
            canvas.translate(-getPaddingTop(), -(mLastOffset + 1) * width);
            mRightEdge.setSize(height, width);
            needsInvalidate |= mRightEdge.draw(canvas);
            canvas.restoreToCount(restoreCount);
        }
    } else {
        mLeftEdge.finish();
        mRightEdge.finish();
    }

    if (needsInvalidate) {
        // Keep animating
        postInvalidateOnAnimation();
    }
}

From source file:example.luojing.androidsourceanalysis.ViewPager.java

/**
 * ?????/*from   ww w .  j ava 2 s  .co  m*/
 */
@Override
public void draw(Canvas canvas) {
    super.draw(canvas);
    boolean needsInvalidate = false;

    final int overScrollMode = getOverScrollMode();
    if (overScrollMode == View.OVER_SCROLL_ALWAYS || (overScrollMode == View.OVER_SCROLL_IF_CONTENT_SCROLLS
            && mAdapter != null && mAdapter.getCount() > 1)) {
        if (!mLeftEdge.isFinished()) {
            final int restoreCount = canvas.save();
            final int height = getHeight() - getPaddingTop() - getPaddingBottom();
            final int width = getWidth();

            canvas.rotate(270);
            canvas.translate(-height + getPaddingTop(), mFirstOffset * width);
            mLeftEdge.setSize(height, width);
            needsInvalidate |= mLeftEdge.draw(canvas);
            canvas.restoreToCount(restoreCount);
        }
        if (!mRightEdge.isFinished()) {
            final int restoreCount = canvas.save();
            final int width = getWidth();
            final int height = getHeight() - getPaddingTop() - getPaddingBottom();

            canvas.rotate(90);
            canvas.translate(-getPaddingTop(), -(mLastOffset + 1) * width);
            mRightEdge.setSize(height, width);
            needsInvalidate |= mRightEdge.draw(canvas);
            canvas.restoreToCount(restoreCount);
        }
    } else {
        mLeftEdge.finish();
        mRightEdge.finish();
    }

    if (needsInvalidate) {
        // Keep animating
        ViewCompat.postInvalidateOnAnimation(this);
    }
}

From source file:com.example.sky.test.view.ViewPager.java

@Override
public void draw(Canvas canvas) {
    super.draw(canvas);
    boolean needsInvalidate = false;

    final int overScrollMode = getOverScrollMode();
    if (overScrollMode == View.OVER_SCROLL_ALWAYS || (overScrollMode == View.OVER_SCROLL_IF_CONTENT_SCROLLS
            && mAdapter != null && mAdapter.getCount() > 1)) {
        if (!mLeftEdge.isFinished()) {
            final int restoreCount = canvas.save();
            final int height = getHeight() - getPaddingTop() - getPaddingBottom();
            final int width = getWidth();

            canvas.rotate(270);//  w  w w.ja  v  a  2 s  . co  m
            canvas.translate(-height + getPaddingTop(), mFirstOffset * width);
            mLeftEdge.setSize(height, width);
            needsInvalidate |= mLeftEdge.draw(canvas);
            canvas.restoreToCount(restoreCount);
        }
        if (!mRightEdge.isFinished()) {
            final int restoreCount = canvas.save();
            final int width = getWidth();
            final int height = getHeight() - getPaddingTop() - getPaddingBottom();

            canvas.rotate(90);
            canvas.translate(-getPaddingTop(), -(mLastOffset + 1) * width);
            mRightEdge.setSize(height, width);
            needsInvalidate |= mRightEdge.draw(canvas);
            canvas.restoreToCount(restoreCount);
        }
    } else {
        mLeftEdge.finish();
        mRightEdge.finish();
    }

    if (needsInvalidate) {
        // Keep animating
        ViewCompat.postInvalidateOnAnimation(this);
    }
}