All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.holoeverywhere.slidingmenu.CustomViewAbove Maven / Gradle / Ivy


package org.holoeverywhere.slidingmenu;

import org.holoeverywhere.internal._ViewGroup;
import org.holoeverywhere.slidingmenu.SlidingMenu.OnClosedListener;
import org.holoeverywhere.slidingmenu.SlidingMenu.OnOpenedListener;
import org.holoeverywhere.widget.FrameLayout;
import org.holoeverywhere.widget.LinearLayout;
import org.holoeverywhere.widget.Scroller;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.support.v4.view.KeyEventCompat;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.VelocityTrackerCompat;
import android.support.v4.view.ViewConfigurationCompat;
import android.util.AttributeSet;
import android.util.FloatMath;
import android.util.Log;
import android.util.TypedValue;
import android.view.FocusFinder;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.SoundEffectConstants;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.animation.Interpolator;

public class CustomViewAbove extends _ViewGroup {

    public class Content extends FrameLayout {
        public Content(Context context) {
            super(context);
        }

        @Override
        public boolean onInterceptTouchEvent(MotionEvent event) {
            if (event.getX() < getPaddingLeft()) {
                return false;
            }
            return super.onInterceptTouchEvent(event);
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            return super.onTouchEvent(event);
        }
    }

    /**
     * Callback interface for responding to changing state of the selected page.
     */
    public interface OnPageChangeListener {

        /**
         * This method will be invoked when the current page is scrolled, either
         * as part of a programmatically initiated smooth scroll or a user
         * initiated touch scroll.
         * 
         * @param position Position index of the first page currently being
         *            displayed. Page position+1 will be visible if
         *            positionOffset is nonzero.
         * @param positionOffset Value from [0, 1) indicating the offset from
         *            the page at position.
         * @param positionOffsetPixels Value in pixels indicating the offset
         *            from position.
         */
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels);

        /**
         * This method will be invoked when a new page becomes selected.
         * Animation is not necessarily complete.
         * 
         * @param position Position index of the new selected page.
         */
        public void onPageSelected(int position);

    }

    /**
     * Simple implementation of the {@link OnPageChangeListener} interface with
     * stub implementations of each method. Extend this if you do not intend to
     * override every method of {@link OnPageChangeListener}.
     */
    public static class SimpleOnPageChangeListener implements OnPageChangeListener {

        @Override
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
            // This space for rent
        }

        public void onPageScrollStateChanged(int state) {
            // This space for rent
        }

        @Override
        public void onPageSelected(int position) {
            // This space for rent
        }

    }

    private class Window extends FrameLayout {

        public Window(Context context) {
            super(context);
        }

        @Override
        public boolean onInterceptTouchEvent(MotionEvent event) {
            return false;
        }

        @Override
        public boolean onTouchEvent(MotionEvent event) {
            return false;
        }

    }

    private static final boolean DEBUG = false;

    /**
     * Sentinel value for no current active pointer. Used by
     * {@link #mActivePointerId}.
     */
    private static final int INVALID_POINTER = -1;

    private static final int MAX_SETTLE_DURATION = 600; // ms
    private static final int MIN_DISTANCE_FOR_FLING = 25; // dips

    private static final Interpolator sInterpolator = new Interpolator() {
        @Override
        public float getInterpolation(float t) {
            t -= 1.0f;
            return t * t * t * t * t + 1.0f;
        }
    };
    private static final String TAG = "CustomViewAbove";

    private static final boolean USE_CACHE = false;
    /**
     * ID of the active pointer. This is used to retain consistency during
     * drags/flings if multiple pointers are used.
     */
    protected int mActivePointerId = INVALID_POINTER;

    private final Paint mBehindFadePaint = new Paint();

    // private OnCloseListener mCloseListener;
    // private OnOpenListener mOpenListener;
    private OnClosedListener mClosedListener;

    private Content mContent;
    private int mCurItem;
    private CustomViewBehind mCustomViewBehind;
    private boolean mEnabled = true;
    private float mFadeDegree = 1.0f;
    // for the fade
    private boolean mFadeEnabled;
    private int mFlingDistance;

    private float mInitialMotionX;
    private OnPageChangeListener mInternalPageChangeListener;
    private boolean mIsBeingDragged;
    private boolean mIsUnableToDrag;

    /**
     * Position of the last motion event.
     */
    private float mLastMotionX;
    private float mLastMotionY;
    private boolean mLastTouchAllowed = false;
    protected int mMaximumVelocity;

    private Window mMenu;
    private int mMinimumVelocity;

    private OnPageChangeListener mOnPageChangeListener;
    private OnOpenedListener mOpenedListener;

    // private int mScrollState = SCROLL_STATE_IDLE;

    private Scroller mScroller;

    private boolean mScrolling;

    private boolean mScrollingCacheEnabled;

    private float mScrollScale;

    // variables for drawing
    private float mScrollX = 0.0f;

    private View mSelectedView;

    private Bitmap mSelectorDrawable;

    // for the indicator
    private boolean mSelectorEnabled = true;

    private Drawable mShadowDrawable;

    private int mShadowWidth;

    private final int mSlidingMenuThreshold = 20;

    protected int mTouchMode = SlidingMenu.TOUCHMODE_MARGIN;

    private int mTouchModeBehind = SlidingMenu.TOUCHMODE_MARGIN;

    // private boolean mIsUnableToDrag;
    private int mTouchSlop;

    /**
     * Determines speed during touch scrolling
     */
    protected VelocityTracker mVelocityTracker;

    public CustomViewAbove(Context context) {
        this(context, null);
    }

    public CustomViewAbove(Context context, AttributeSet attrs) {
        this(context, attrs, true);
    }

    public CustomViewAbove(Context context, AttributeSet attrs, boolean isAbove) {
        super(context, attrs);
        initCustomViewAbove(isAbove);
    }

    public boolean arrowScroll(int direction) {
        View currentFocused = findFocus();
        if (currentFocused == this) {
            currentFocused = null;
        }

        boolean handled = false;

        View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused,
                direction);
        if (nextFocused != null && nextFocused != currentFocused) {
            if (direction == View.FOCUS_LEFT) {
                // If there is nothing to the left, or this is causing us to
                // jump to the right, then what we really want to do is page
                // left.
                if (currentFocused != null && nextFocused.getLeft() >= currentFocused.getLeft()) {
                    handled = pageLeft();
                } else {
                    handled = nextFocused.requestFocus();
                }
            } else if (direction == View.FOCUS_RIGHT) {
                // If there is nothing to the right, or this is causing us to
                // jump to the left, then what we really want to do is page
                // right.
                if (currentFocused != null && nextFocused.getLeft() <= currentFocused.getLeft()) {
                    handled = pageRight();
                } else {
                    handled = nextFocused.requestFocus();
                }
            }
        } else if (direction == FOCUS_LEFT || direction == FOCUS_BACKWARD) {
            // Trying to move left and nothing there; try to page.
            handled = pageLeft();
        } else if (direction == FOCUS_RIGHT || direction == FOCUS_FORWARD) {
            // Trying to move right and nothing there; try to page.
            handled = pageRight();
        }
        if (handled) {
            playSoundEffect(SoundEffectConstants.getContantForFocusDirection(direction));
        }
        return handled;
    }

    /**
     * Tests scrollability within child views of v given a delta of dx.
     * 
     * @param v View to test for horizontal scrollability
     * @param checkV Whether the view v passed should itself be checked for
     *            scrollability (true), or just its children (false).
     * @param dx Delta scrolled in pixels
     * @param x X coordinate of the active touch point
     * @param y Y coordinate of the active touch point
     * @return true if child views of v can be scrolled by delta of dx.
     */
    protected boolean canScroll(View v, boolean checkV, int dx, int x, int y) {
        if (v instanceof ViewGroup) {
            final ViewGroup group = (ViewGroup) v;
            final int scrollX = v.getScrollX();
            final int scrollY = v.getScrollY();
            final int count = group.getChildCount();
            // Count backwards - let topmost views consume scroll distance
            // first.
            for (int i = count - 1; i >= 0; i--) {
                final View child = group.getChildAt(i);
                if (x + scrollX >= child.getLeft() && x + scrollX < child.getRight() &&
                        y + scrollY >= child.getTop() && y + scrollY < child.getBottom() &&
                        canScroll(child, true, dx, x + scrollX - child.getLeft(),
                                y + scrollY - child.getTop())) {
                    return true;
                }
            }
        }

        return checkV && android.support.v4.view.ViewCompat.canScrollHorizontally(v, -dx);
    }

    private void completeScroll() {
        boolean needPopulate = mScrolling;
        if (needPopulate) {
            // Done with scroll, no longer want to cache view drawing.
            setScrollingCacheEnabled(false);
            mScroller.abortAnimation();
            int oldX = getScrollX();
            int oldY = getScrollY();
            int x = mScroller.getCurrX();
            int y = mScroller.getCurrY();
            if (oldX != x || oldY != y) {
                scrollTo(x, y);
            }
            if (isMenuOpen()) {
                if (mOpenedListener != null) {
                    mOpenedListener.onOpened();
                }
            } else {
                if (mClosedListener != null) {
                    mClosedListener.onClosed();
                }
            }
        }
        mScrolling = false;
    }

    @Override
    public void computeScroll() {
        if (!mScroller.isFinished()) {
            if (mScroller.computeScrollOffset()) {
                if (DEBUG) {
                    Log.i(TAG, "computeScroll: still scrolling");
                }
                int oldX = getScrollX();
                int oldY = getScrollY();
                int x = mScroller.getCurrX();
                int y = mScroller.getCurrY();

                if (oldX != x || oldY != y) {
                    scrollTo(x, y);
                    pageScrolled(x);
                }

                // Keep on drawing until the animation has finished.
                invalidate();
                return;
            }
        }

        // Done with scroll, clean up state.
        completeScroll();
    }

    private int determineTargetPage(int currentPage, float pageOffset, int velocity, int deltaX) {
        int targetPage;
        if (Math.abs(deltaX) > mFlingDistance && Math.abs(velocity) > mMinimumVelocity) {
            targetPage = velocity > 0 ? currentPage : currentPage + 1;
        } else {
            targetPage = (int) (currentPage + pageOffset + 0.5f);
        }
        return targetPage;
    }

    @Override
    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(canvas);
        // Draw the margin drawable if needed.
        if (mShadowWidth > 0 && mShadowDrawable != null) {
            final int left = getContentLeft() - mShadowWidth;
            mShadowDrawable.setBounds(left, 0, left + mShadowWidth, getHeight());
            mShadowDrawable.draw(canvas);
        }

        if (mFadeEnabled) {
            onDrawBehindFade(canvas, getPercentOpen());
        }

        if (mSelectorEnabled) {
            onDrawMenuSelector(canvas, getPercentOpen());
        }
    }

    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {
        // Let the focused view and/or our descendants get the key first
        return super.dispatchKeyEvent(event) || executeKeyEvent(event);
    }

    // We want the duration of the page snap animation to be influenced by the
    // distance that
    // the screen has to travel, however, we don't want this duration to be
    // effected in a
    // purely linear fashion. Instead, we use this method to moderate the effect
    // that the distance
    // of travel has on the overall snap duration.
    float distanceInfluenceForSnapDuration(float f) {
        f -= 0.5f; // center the values about 0.
        f *= 0.3f * Math.PI / 2.0f;
        return FloatMath.sin(f);
    }

    @Override
    protected void drawableStateChanged() {
        super.drawableStateChanged();
        final Drawable d = mShadowDrawable;
        if (d != null && d.isStateful()) {
            d.setState(getDrawableState());
        }
    }

    private void endDrag() {
        mIsBeingDragged = false;
        mIsUnableToDrag = false;
        mLastTouchAllowed = false;

        if (mVelocityTracker != null) {
            mVelocityTracker.recycle();
            mVelocityTracker = null;
        }
    }

    /**
     * You can call this function yourself to have the scroll view perform
     * scrolling from a key event, just as if the event had been dispatched to
     * it by the view hierarchy.
     * 
     * @param event The key event to execute.
     * @return Return true if the event was handled, else false.
     */
    public boolean executeKeyEvent(KeyEvent event) {
        boolean handled = false;
        if (event.getAction() == KeyEvent.ACTION_DOWN) {
            switch (event.getKeyCode()) {
                case KeyEvent.KEYCODE_DPAD_LEFT:
                    handled = arrowScroll(FOCUS_LEFT);
                    break;
                case KeyEvent.KEYCODE_DPAD_RIGHT:
                    handled = arrowScroll(FOCUS_RIGHT);
                    break;
                case KeyEvent.KEYCODE_TAB:
                    if (Build.VERSION.SDK_INT >= 11) {
                        // The focus finder had a bug handling FOCUS_FORWARD and
                        // FOCUS_BACKWARD
                        // before Android 3.0. Ignore the tab key on those
                        // devices.
                        if (KeyEventCompat.hasNoModifiers(event)) {
                            handled = arrowScroll(FOCUS_FORWARD);
                        } else if (KeyEventCompat.hasModifiers(event, KeyEvent.META_SHIFT_ON)) {
                            handled = arrowScroll(FOCUS_BACKWARD);
                        }
                    }
                    break;
            }
        }
        return handled;
    }

    /**
     * Pads our content window so that it fits within the system windows.
     * 
     * @param insets The insets by which we need to offset our view.
     * @return True since we handled the padding change.
     */
    @Override
    protected boolean fitSystemWindows(Rect insets) {

        if (mContent != null) {
            int leftPadding = mContent.getPaddingLeft() + insets.left;
            int rightPadding = mContent.getPaddingRight() + insets.right;
            int topPadding = insets.top;
            int bottomPadding = insets.bottom;
            mContent.setPadding(leftPadding, topPadding, rightPadding, bottomPadding);
            return true;
        }

        return super.fitSystemWindows(insets);
    }

    public int getBehindWidth() {
        if (mCustomViewBehind == null) {
            return 0;
        } else {
            return mCustomViewBehind.getWidth();
        }
    }

    public int getChildLeft(int i) {
        if (i <= 0) {
            return 0;
        }
        return getChildWidth(i - 1) + getChildLeft(i - 1);
    }

    public int getChildRight(int i) {
        return getChildLeft(i) + getChildWidth(i);
    }

    public int getChildWidth(int i) {
        if (i <= 0) {
            return getBehindWidth();
        } else {
            return getChildAt(i).getWidth();
        }
    }

    public int getContentLeft() {
        return mContent.getLeft() + mContent.getPaddingLeft();
    }

    public int getCurrentItem() {
        return mCurItem;
    }

    public int getCustomWidth() {
        int i = isMenuOpen() ? 0 : 1;
        return getChildWidth(i);
    }

    public int getDestScrollX() {
        if (isMenuOpen()) {
            return getBehindWidth();
        } else {
            return 0;
        }
    }

    public int getDestScrollX(int page) {
        switch (page) {
            case 0:
                return mContent.getPaddingLeft();
            case 1:
                return mContent.getLeft();
        }
        return 0;
    }

    protected float getPercentOpen() {
        return (getBehindWidth() - mScrollX) / getBehindWidth();
    }

    public float getScrollScale() {
        return mScrollScale;
    }

    private int getSelectedTop() {
        int y = mSelectedView.getTop();
        y += (mSelectedView.getHeight() - mSelectorDrawable.getHeight()) / 2;
        return y;
    }

    /**
     * Return the margin between pages.
     * 
     * @return The size of the margin in pixels
     */
    public int getShadowWidth() {
        return mShadowWidth;
    }

    public int getTouchMode() {
        return mTouchMode;
    }

    protected int getTouchModeBehind() {
        return mTouchModeBehind;
    }

    void initCustomViewAbove() {
        initCustomViewAbove(false);
    }

    void initCustomViewAbove(boolean isAbove) {
        setWillNotDraw(false);
        setDescendantFocusability(FOCUS_AFTER_DESCENDANTS);
        setFocusable(true);
        final Context context = getContext();
        mScroller = new Scroller(context, sInterpolator);
        final ViewConfiguration configuration = ViewConfiguration.get(context);
        mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
        mMinimumVelocity = configuration.getScaledMinimumFlingVelocity();
        mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();
        setInternalPageChangeListener(new SimpleOnPageChangeListener() {

            @Override
            public void onPageSelected(int position) {
                if (mCustomViewBehind != null) {
                    switch (position) {
                        case 0:
                            mCustomViewBehind.setChildrenEnabled(true);
                            break;
                        case 1:
                            mCustomViewBehind.setChildrenEnabled(false);
                            break;
                    }
                }
            }

        });

        final float density = context.getResources().getDisplayMetrics().density;
        mFlingDistance = (int) (MIN_DISTANCE_FOR_FLING * density);

        mMenu = new Window(getContext());
        super.addView(mMenu);
        mContent = new Content(getContext());
        super.addView(mContent);

        if (isAbove) {
            View v = new LinearLayout(getContext());
            v.setBackgroundResource(android.R.color.transparent);
            setMenu(v);
        }

    }

    public boolean isMenuOpen() {
        return getCurrentItem() == 0;
    }

    public boolean isSlidingEnabled() {
        return mEnabled;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
    }

    private void onDrawBehindFade(Canvas canvas, float openPercent) {
        final int alpha = (int) (mFadeDegree * 255 * Math.abs(1 - openPercent));
        if (alpha > 0) {
            mBehindFadePaint.setColor(Color.argb(alpha, 0, 0, 0));
            canvas.drawRect(0, 0, getContentLeft(), getHeight(), mBehindFadePaint);
        }
    }

    private void onDrawMenuSelector(Canvas canvas, float openPercent) {
        if (mSelectorDrawable != null && mSelectedView != null) {
            String tag = (String) mSelectedView.getTag(R.id.selected_view);
            if (tag.equals(TAG + "SelectedView")) {
                int right = getChildLeft(1);
                int left = (int) (right - mSelectorDrawable.getWidth() * openPercent);

                canvas.save();
                canvas.clipRect(left, 0, right, getHeight());
                canvas.drawBitmap(mSelectorDrawable, left, getSelectedTop(), null);
                canvas.restore();
            }
        }
    }

    @SuppressWarnings("unused")
    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {

        if (!mEnabled) {
            return false;
        }

        final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;

        if (action == MotionEvent.ACTION_DOWN && DEBUG) {
            Log.v(TAG, "Received ACTION_DOWN");
        }

        if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
            mIsBeingDragged = false;
            mIsUnableToDrag = false;
            mActivePointerId = INVALID_POINTER;
            if (mVelocityTracker != null) {
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            return false;
        }

        if (action != MotionEvent.ACTION_DOWN) {
            if (mIsBeingDragged) {
                return true;
            } else if (mIsUnableToDrag) {
                return false;
            }
        }

        switch (action) {
            case MotionEvent.ACTION_MOVE:
                final int activePointerId = mActivePointerId;
                if (activePointerId == INVALID_POINTER) {
                    break;
                }

                final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
                if (pointerIndex == -1) {
                    mActivePointerId = INVALID_POINTER;
                    break;
                }
                final float x = MotionEventCompat.getX(ev, pointerIndex);
                final float dx = x - mLastMotionX;
                final float xDiff = Math.abs(dx);
                final float y = MotionEventCompat.getY(ev, pointerIndex);
                final float yDiff = Math.abs(y - mLastMotionY);
                if (xDiff > mTouchSlop && xDiff > yDiff && thisSlideAllowed(dx)) {
                    if (DEBUG) {
                        Log.v(TAG, "Starting drag! from onInterceptTouch");
                    }
                    mIsBeingDragged = true;
                    mLastMotionX = x;
                    setScrollingCacheEnabled(true);
                } else if (yDiff > mTouchSlop) {
                    mIsUnableToDrag = true;
                }
                break;

            case MotionEvent.ACTION_DOWN:
                mActivePointerId = ev.getAction()
                        & (Build.VERSION.SDK_INT >= 8 ? MotionEvent.ACTION_POINTER_INDEX_MASK :
                                MotionEvent.ACTION_POINTER_INDEX_MASK);
                mLastMotionX = mInitialMotionX = MotionEventCompat.getX(ev, mActivePointerId);
                mLastMotionY = MotionEventCompat.getY(ev, mActivePointerId);
                if (thisTouchAllowed(ev)) {
                    mIsBeingDragged = false;
                    mIsUnableToDrag = false;
                    if (isMenuOpen() && mInitialMotionX > getBehindWidth()) {
                        return true;
                    }
                } else {
                    mIsUnableToDrag = true;
                }
                break;
            case MotionEventCompat.ACTION_POINTER_UP:
                onSecondaryPointerUp(ev);
                break;
        }

        if (!mIsBeingDragged) {
            if (mVelocityTracker == null) {
                mVelocityTracker = VelocityTracker.obtain();
            }
            mVelocityTracker.addMovement(ev);
        }

        return mIsBeingDragged;
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        final int width = r - l;
        final int height = b - t;

        int contentLeft = getChildLeft(1);
        mMenu.layout(0, 0, width, height);
        mContent.layout(contentLeft, 0, contentLeft + width, height);
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

        int width = getDefaultSize(0, widthMeasureSpec);
        int height = getDefaultSize(0, heightMeasureSpec);
        setMeasuredDimension(width, height);

        final int contentWidth = getChildMeasureSpec(widthMeasureSpec, 0, width);
        final int contentHeight = getChildMeasureSpec(heightMeasureSpec, 0, height);
        mContent.measure(contentWidth, contentHeight);

        final int menuWidth = getChildMeasureSpec(widthMeasureSpec, 0, getBehindWidth());
        mMenu.measure(menuWidth, contentHeight);
    }

    /**
     * This method will be invoked when the current page is scrolled, either as
     * part of a programmatically initiated smooth scroll or a user initiated
     * touch scroll. If you override this method you must call through to the
     * superclass implementation (e.g. super.onPageScrolled(position, offset,
     * offsetPixels)) before onPageScrolled returns.
     * 
     * @param position Position index of the first page currently being
     *            displayed. Page position+1 will be visible if positionOffset
     *            is nonzero.
     * @param offset Value from [0, 1) indicating the offset from the page at
     *            position.
     * @param offsetPixels Value in pixels indicating the offset from position.
     */
    protected void onPageScrolled(int position, float offset, int offsetPixels) {
        if (mOnPageChangeListener != null) {
            mOnPageChangeListener.onPageScrolled(position, offset, offsetPixels);
        }
        if (mInternalPageChangeListener != null) {
            mInternalPageChangeListener.onPageScrolled(position, offset, offsetPixels);
        }
    }

    private void onSecondaryPointerUp(MotionEvent ev) {
        if (DEBUG) {
            Log.v(TAG, "onSecondaryPointerUp called");
        }
        final int pointerIndex = MotionEventCompat.getActionIndex(ev);
        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        if (pointerId == mActivePointerId) {
            // This was our active pointer going up. Choose a new
            // active pointer and adjust accordingly.
            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
            mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
            if (mVelocityTracker != null) {
                mVelocityTracker.clear();
            }
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        // Make sure scroll position is set correctly.
        if (w != oldw) {
            // [ChrisJ] - This fixes the onConfiguration change for orientation
            // issue..
            // maybe worth having a look why the recomputeScroll pos is screwing
            // up?
            completeScroll();
            scrollTo(getChildLeft(mCurItem), getScrollY());
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if (!mEnabled) {
            return false;
        }

        if (!mIsBeingDragged && !mLastTouchAllowed && !thisTouchAllowed(ev)) {
            return false;
        }

        final int action = ev.getAction();

        if (action == MotionEvent.ACTION_UP ||
                action == MotionEvent.ACTION_CANCEL ||
                action == MotionEvent.ACTION_OUTSIDE) {
            mLastTouchAllowed = false;
        } else {
            mLastTouchAllowed = true;
        }

        if (mVelocityTracker == null) {
            mVelocityTracker = VelocityTracker.obtain();
        }
        mVelocityTracker.addMovement(ev);

        switch (action & MotionEventCompat.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN:
                /*
                 * If being flinged and user touches, stop the fling. isFinished
                 * will be false if being flinged.
                 */
                completeScroll();

                // Remember where the motion event started
                mLastMotionX = mInitialMotionX = ev.getX();
                mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
                break;
            case MotionEvent.ACTION_MOVE:
                if (!mIsBeingDragged) {
                    final int pointerIndex = MotionEventCompat.findPointerIndex(ev,
                            mActivePointerId);
                    if (pointerIndex == -1) {
                        mActivePointerId = INVALID_POINTER;
                        break;
                    }
                    final float x = MotionEventCompat.getX(ev, pointerIndex);
                    final float xDiff = Math.abs(x - mLastMotionX);
                    final float y = MotionEventCompat.getY(ev, pointerIndex);
                    final float yDiff = Math.abs(y - mLastMotionY);
                    if (DEBUG) {
                        Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
                    }
                    if (xDiff > mTouchSlop && xDiff > yDiff) {
                        if (DEBUG) {
                            Log.v(TAG, "Starting drag! from onTouch");
                        }
                        mIsBeingDragged = true;
                        mLastMotionX = x;
                        setScrollingCacheEnabled(true);
                    }
                }
                if (mIsBeingDragged) {
                    // Scroll to follow the motion event
                    final int activePointerIndex = MotionEventCompat.findPointerIndex(
                            ev, mActivePointerId);
                    if (activePointerIndex == -1) {
                        mActivePointerId = INVALID_POINTER;
                        break;
                    }
                    final float x = MotionEventCompat.getX(ev, activePointerIndex);
                    final float deltaX = mLastMotionX - x;
                    mLastMotionX = x;
                    float oldScrollX = getScrollX();
                    float scrollX = oldScrollX + deltaX;
                    final float leftBound = getDestScrollX(0);
                    final float rightBound = getDestScrollX(1);
                    if (scrollX < leftBound) {
                        scrollX = leftBound;
                    } else if (scrollX > rightBound) {
                        scrollX = rightBound;
                    }
                    // Don't lose the rounded component
                    mLastMotionX += scrollX - (int) scrollX;
                    scrollTo((int) scrollX, getScrollY());
                    pageScrolled((int) scrollX);
                }
                break;
            case MotionEvent.ACTION_UP:
                if (mIsBeingDragged) {
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                    int initialVelocity = (int) VelocityTrackerCompat.getXVelocity(
                            velocityTracker, mActivePointerId);
                    final int widthWithMargin = getChildWidth(mCurItem) + mShadowWidth;
                    final int scrollX = getScrollX();
                    final int currentPage = scrollX / widthWithMargin;
                    final float pageOffset = (float) (scrollX % widthWithMargin) / widthWithMargin;
                    final int activePointerIndex =
                            MotionEventCompat.findPointerIndex(ev, mActivePointerId);
                    final float x = MotionEventCompat.getX(ev, activePointerIndex);
                    final int totalDelta = (int) (x - mInitialMotionX);
                    int nextPage = determineTargetPage(currentPage, pageOffset, initialVelocity,
                            totalDelta);
                    setCurrentItemInternal(nextPage, true, true, initialVelocity);

                    mActivePointerId = INVALID_POINTER;
                    endDrag();
                } else if (isMenuOpen()) {
                    // close the menu
                    setCurrentItem(1);
                }
                break;
            case MotionEvent.ACTION_CANCEL:
                if (mIsBeingDragged) {
                    setCurrentItemInternal(mCurItem, true, true);
                    mActivePointerId = INVALID_POINTER;
                    endDrag();
                }
                break;
            case MotionEventCompat.ACTION_POINTER_DOWN: {
                final int index = MotionEventCompat.getActionIndex(ev);
                final float x = MotionEventCompat.getX(ev, index);
                mLastMotionX = x;
                mActivePointerId = MotionEventCompat.getPointerId(ev, index);
                break;
            }
            case MotionEventCompat.ACTION_POINTER_UP:
                onSecondaryPointerUp(ev);
                mLastMotionX = MotionEventCompat.getX(ev,
                        MotionEventCompat.findPointerIndex(ev, mActivePointerId));
                break;
        }
        if (mActivePointerId == INVALID_POINTER) {
            mLastTouchAllowed = false;
        }
        return true;
    }

    boolean pageLeft() {
        if (mCurItem > 0) {
            setCurrentItem(mCurItem - 1, true);
            return true;
        }
        return false;
    }

    boolean pageRight() {
        if (mCurItem < 1) {
            setCurrentItem(mCurItem + 1, true);
            return true;
        }
        return false;
    }

    private void pageScrolled(int xpos) {
        final int widthWithMargin = getChildWidth(mCurItem) + mShadowWidth;
        final int position = xpos / widthWithMargin;
        final int offsetPixels = xpos % widthWithMargin;
        final float offset = (float) offsetPixels / widthWithMargin;

        onPageScrolled(position, offset, offsetPixels);
    }

    @Override
    public void scrollTo(int x, int y) {
        super.scrollTo(x, y);
        mScrollX = x;
        if (mCustomViewBehind != null && mEnabled) {
            mCustomViewBehind.scrollTo((int) (x * mScrollScale), y);
        }
        if (mShadowDrawable != null || mSelectorDrawable != null) {
            invalidate();
        }
    }

    public void setAboveOffset(int i) {
        // RelativeLayout.LayoutParams params =
        // ((RelativeLayout.LayoutParams)mContent.getLayoutParams());
        // params.setMargins(i, params.topMargin, params.rightMargin,
        // params.bottomMargin);
        mContent.setPadding(i, mContent.getPaddingTop(),
                mContent.getPaddingRight(), mContent.getPaddingBottom());
    }

    public void setBehindFadeDegree(float f) {
        if (f > 1.0f || f < 0.0f) {
            throw new IllegalStateException("The BehindFadeDegree must be between 0.0f and 1.0f");
        }
        mFadeDegree = f;
    }

    public void setBehindFadeEnabled(boolean b) {
        mFadeEnabled = b;
    }

    public void setContent(View v) {
        if (mContent.getChildCount() > 0) {
            mContent.removeAllViews();
        }
        mContent.addView(v);
    }

    /**
     * Set the currently selected page. If the CustomViewPager has already been
     * through its first layout there will be a smooth animated transition
     * between the current item and the specified item.
     * 
     * @param item Item index to select
     */
    public void setCurrentItem(int item) {
        setCurrentItemInternal(item, true, false);
    }

    /**
     * Set the currently selected page.
     * 
     * @param item Item index to select
     * @param smoothScroll True to smoothly scroll to the new item, false to
     *            transition immediately
     */
    public void setCurrentItem(int item, boolean smoothScroll) {
        setCurrentItemInternal(item, smoothScroll, false);
    }

    void setCurrentItemInternal(int item, boolean smoothScroll, boolean always) {
        setCurrentItemInternal(item, smoothScroll, always, 0);
    }

    void setCurrentItemInternal(int item, boolean smoothScroll, boolean always, int velocity) {
        if (!always && mCurItem == item && mMenu != null && mContent != null) {
            setScrollingCacheEnabled(false);
            return;
        }
        if (item < 0) {
            item = 0;
        } else if (item >= 2) {
            item = 1;
        }
        final boolean dispatchSelected = mCurItem != item;
        mCurItem = item;
        final int destX = getDestScrollX(mCurItem);
        if (dispatchSelected && mOnPageChangeListener != null) {
            mOnPageChangeListener.onPageSelected(item);
        }
        if (dispatchSelected && mInternalPageChangeListener != null) {
            mInternalPageChangeListener.onPageSelected(item);
        }
        if (smoothScroll) {
            smoothScrollTo(destX, 0, velocity);
        } else {
            completeScroll();
            scrollTo(destX, 0);
        }
    }

    public void setCustomViewBehind(CustomViewBehind cvb) {
        mCustomViewBehind = cvb;
    }

    /**
     * Set a separate OnPageChangeListener for internal use by the support
     * library.
     * 
     * @param listener Listener to set
     * @return The old listener that was set, if any.
     */
    OnPageChangeListener setInternalPageChangeListener(OnPageChangeListener listener) {
        OnPageChangeListener oldListener = mInternalPageChangeListener;
        mInternalPageChangeListener = listener;
        return oldListener;
    }

    protected void setMenu(View v) {
        if (mMenu.getChildCount() > 0) {
            mMenu.removeAllViews();
        }
        mMenu.addView(v);
    }

    public void setOnClosedListener(OnClosedListener l) {
        mClosedListener = l;
    }

    /*
     * public void setOnOpenListener(OnOpenListener l) { mOpenListener = l; }
     * public void setOnCloseListener(OnCloseListener l) { mCloseListener = l; }
     */
    public void setOnOpenedListener(OnOpenedListener l) {
        mOpenedListener = l;
    }

    /**
     * Set a listener that will be invoked whenever the page changes or is
     * incrementally scrolled. See {@link OnPageChangeListener}.
     * 
     * @param listener Listener to set
     */
    public void setOnPageChangeListener(OnPageChangeListener listener) {
        mOnPageChangeListener = listener;
    }

    private void setScrollingCacheEnabled(boolean enabled) {
        if (mScrollingCacheEnabled != enabled) {
            mScrollingCacheEnabled = enabled;
            if (USE_CACHE) {
                final int size = getChildCount();
                for (int i = 0; i < size; ++i) {
                    final View child = getChildAt(i);
                    if (child.getVisibility() != GONE) {
                        child.setDrawingCacheEnabled(enabled);
                    }
                }
            }
        }
    }

    public void setScrollScale(float f) {
        if (f < 0 && f > 1) {
            throw new IllegalStateException("ScrollScale must be between 0 and 1");
        }
        mScrollScale = f;
    }

    public void setSelectedView(View v) {
        if (mSelectedView != null) {
            mSelectedView.setTag(R.id.selected_view, null);
            mSelectedView = null;
        }
        if (v.getParent() != null) {
            mSelectedView = v;
            mSelectedView.setTag(R.id.selected_view, TAG + "SelectedView");
            invalidate();
        }
    }

    public void setSelectorBitmap(Bitmap b) {
        mSelectorDrawable = b;
        refreshDrawableState();
    }

    public void setSelectorEnabled(boolean b) {
        mSelectorEnabled = b;
    }

    /**
     * Set a drawable that will be used to fill the margin between pages.
     * 
     * @param d Drawable to display between pages
     */
    public void setShadowDrawable(Drawable d) {
        mShadowDrawable = d;
        refreshDrawableState();
        setWillNotDraw(false);
        invalidate();
    }

    /**
     * Set a drawable that will be used to fill the margin between pages.
     * 
     * @param resId Resource ID of a drawable to display between pages
     */
    public void setShadowDrawable(int resId) {
        setShadowDrawable(getContext().getResources().getDrawable(resId));
    }

    /**
     * Set the margin between pages.
     * 
     * @param shadowWidth Distance between adjacent pages in pixels
     * @see #getShadowWidth()
     * @see #setShadowDrawable(Drawable)
     * @see #setShadowDrawable(int)
     */
    public void setShadowWidth(int shadowWidth) {
        mShadowWidth = shadowWidth;
        invalidate();
    }

    public void setSlidingEnabled(boolean b) {
        mEnabled = b;
    }

    public void setTouchMode(int i) {
        mTouchMode = i;
    }

    protected void setTouchModeBehind(int i) {
        mTouchModeBehind = i;
    }

    /**
     * Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
     * 
     * @param x the number of pixels to scroll by on the X axis
     * @param y the number of pixels to scroll by on the Y axis
     */
    void smoothScrollTo(int x, int y) {
        smoothScrollTo(x, y, 0);
    }

    /**
     * Like {@link View#scrollBy}, but scroll smoothly instead of immediately.
     * 
     * @param x the number of pixels to scroll by on the X axis
     * @param y the number of pixels to scroll by on the Y axis
     * @param velocity the velocity associated with a fling, if applicable. (0
     *            otherwise)
     */
    void smoothScrollTo(int x, int y, int velocity) {
        if (getChildCount() == 0) {
            // Nothing to do.
            setScrollingCacheEnabled(false);
            return;
        }
        int sx = getScrollX();
        int sy = getScrollY();
        int dx = x - sx;
        int dy = y - sy;
        if (dx == 0 && dy == 0) {
            completeScroll();
            if (isMenuOpen()) {
                if (mOpenedListener != null) {
                    mOpenedListener.onOpened();
                }
            } else {
                if (mClosedListener != null) {
                    mClosedListener.onClosed();
                }
            }
            return;
        }

        setScrollingCacheEnabled(true);
        mScrolling = true;

        final int width = getCustomWidth();
        final int halfWidth = width / 2;
        final float distanceRatio = Math.min(1f, 1.0f * Math.abs(dx) / width);
        final float distance = halfWidth + halfWidth *
                distanceInfluenceForSnapDuration(distanceRatio);

        int duration = 0;
        velocity = Math.abs(velocity);
        if (velocity > 0) {
            duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
        } else {
            final float pageDelta = (float) Math.abs(dx) / (width + mShadowWidth);
            duration = (int) ((pageDelta + 1) * 100);
            duration = MAX_SETTLE_DURATION;
        }
        duration = Math.min(duration, MAX_SETTLE_DURATION);

        mScroller.startScroll(sx, sy, dx, dy, duration);
        invalidate();
    }

    private boolean thisSlideAllowed(float dx) {
        boolean allowed = false;
        if (isMenuOpen()) {
            allowed = dx < 0;
        } else if (mCustomViewBehind != null) {
            allowed = dx > 0;
        }
        if (DEBUG) {
            Log.v(TAG, "this slide allowed " + allowed);
        }
        return allowed;
    }

    private boolean thisTouchAllowed(MotionEvent ev) {
        int x = (int) (ev.getX() + mScrollX);
        if (isMenuOpen()) {
            switch (mTouchModeBehind) {
                case SlidingMenu.TOUCHMODE_FULLSCREEN:
                    return true;
                case SlidingMenu.TOUCHMODE_NONE:
                    return false;
                case SlidingMenu.TOUCHMODE_MARGIN:
                    return x >= getContentLeft();
                default:
                    return false;
            }
        } else {
            switch (mTouchMode) {
                case SlidingMenu.TOUCHMODE_FULLSCREEN:
                    return true;
                case SlidingMenu.TOUCHMODE_NONE:
                    return false;
                case SlidingMenu.TOUCHMODE_MARGIN:
                    int pixels = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                            mSlidingMenuThreshold, getResources().getDisplayMetrics());
                    int left = getContentLeft();
                    return x >= left && x <= pixels + left;
                default:
                    return false;
            }
        }
    }

    @Override
    protected boolean verifyDrawable(Drawable who) {
        return super.verifyDrawable(who) || who == mShadowDrawable;
    }

}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy