Example usage for android.support.v4.view MotionEventCompat getX

List of usage examples for android.support.v4.view MotionEventCompat getX

  1. HOME
  2. Java
  3. android
  4. android.support.v4.view.*
  5. MotionEventCompat
  6. getX

Introduction

In this page you can find the example usage for android.support.v4.view MotionEventCompat getX.

Prototype

public static float getX(MotionEvent event, int pointerIndex)

Source Link

Document

Call MotionEvent#getX(int) .

Usage

From source file:danonino.danonino_the_game.Core.Labels.PowerUp.java

public int onTouch(MotionEvent event) {
    int index = MotionEventCompat.getActionIndex(event);
    int x;//from   ww w  . ja  v  a  2s. c  om
    int y;

    if (event.getPointerCount() > 1) {
        // The coordinates of the current screen contact, relative to
        // the responding View or Activity.
        x = (int) MotionEventCompat.getX(event, index);
        y = (int) MotionEventCompat.getY(event, index);

    } else {
        // Single touch event
        x = (int) MotionEventCompat.getX(event, index);
        y = (int) MotionEventCompat.getY(event, index);
    }

    if (this.usePowerUpBtn.btn_rect.contains(x, y) || ((event.getActionMasked() == MotionEvent.ACTION_UP
            || event.getActionMasked() == MotionEvent.ACTION_POINTER_UP) && usePowerUpBtnPressed)) {
        this.usePowerUpBtnPressed = !this.usePowerUpBtnPressed;
        this.usePowerUpBtn.onTouch(event);
        return 1;
    }
    return 0;
}

From source file:com.duy.pascal.ui.view.BaseRecycleView.java

@Override
public boolean onInterceptTouchEvent(MotionEvent e) {
    final int action = MotionEventCompat.getActionMasked(e);
    final int actionIndex = MotionEventCompat.getActionIndex(e);

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mScrollPointerId = MotionEventCompat.getPointerId(e, 0);
        mInitialTouchX = (int) (e.getX() + 0.5f);
        mInitialTouchY = (int) (e.getY() + 0.5f);
        return super.onInterceptTouchEvent(e);

    case MotionEventCompat.ACTION_POINTER_DOWN:
        mScrollPointerId = MotionEventCompat.getPointerId(e, actionIndex);
        mInitialTouchX = (int) (MotionEventCompat.getX(e, actionIndex) + 0.5f);
        mInitialTouchY = (int) (MotionEventCompat.getY(e, actionIndex) + 0.5f);
        return super.onInterceptTouchEvent(e);

    case MotionEvent.ACTION_MOVE: {
        final int index = MotionEventCompat.findPointerIndex(e, mScrollPointerId);
        if (index < 0) {
            return false;
        }/*  ww w . ja v  a  2 s  .com*/

        final int x = (int) (MotionEventCompat.getX(e, index) + 0.5f);
        final int y = (int) (MotionEventCompat.getY(e, index) + 0.5f);
        if (getScrollState() != SCROLL_STATE_DRAGGING) {
            final int dx = x - mInitialTouchX;
            final int dy = y - mInitialTouchY;
            final boolean canScrollHorizontally = getLayoutManager().canScrollHorizontally();
            final boolean canScrollVertically = getLayoutManager().canScrollVertically();
            boolean startScroll = false;
            if (canScrollHorizontally && Math.abs(dx) > mTouchSlop
                    && (Math.abs(dx) >= Math.abs(dy) || canScrollVertically)) {
                startScroll = true;
            }
            if (canScrollVertically && Math.abs(dy) > mTouchSlop
                    && (Math.abs(dy) >= Math.abs(dx) || canScrollHorizontally)) {
                startScroll = true;
            }
            return startScroll && super.onInterceptTouchEvent(e);
        }
        return super.onInterceptTouchEvent(e);
    }

    default:
        return super.onInterceptTouchEvent(e);
    }
}

From source file:cn.goodjobs.common.view.photodraweeview.ScaleDragDetector.java

private float getActiveX(MotionEvent ev) {
    try {/*from w  w  w.  j a v  a  2  s.  com*/
        return MotionEventCompat.getX(ev, mActivePointerIndex);
    } catch (Exception e) {
        return ev.getX();
    }
}

From source file:net.henryco.opalette.api.glES.glSurface.view.OPallSurfaceTouchListener.java

@Override
public void onTouchEvent(MotionEvent ev) {
    // Let the ScaleGestureDetector inspect all events.
    scaled = false;//from  ww w. j a  va  2  s. c o m
    if (scaleDetector != null)
        scaleDetector.onTouchEvent(ev);

    final int action = MotionEventCompat.getActionMasked(ev);

    if (!scaled || !scaleMatters) {
        switch (action) {
        case MotionEvent.ACTION_DOWN: {
            final int pointerIndex = MotionEventCompat.getActionIndex(ev);
            final float x = MotionEventCompat.getX(ev, pointerIndex);
            final float y = MotionEventCompat.getY(ev, pointerIndex);

            if (onActionDown != null)
                onActionDown.onActionDown(x, y, ev);

            // Remember where we started (for dragging)
            last[0] = x;
            last[1] = y;
            // Save the ID of this pointer (for dragging)
            mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
            break;
        }

        case MotionEvent.ACTION_MOVE: {
            // Find the index of the active pointer and fetch its position
            final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);

            final float x = MotionEventCompat.getX(ev, pointerIndex);
            final float y = MotionEventCompat.getY(ev, pointerIndex);

            // Calculate the distance moved
            final float dx = x - last[0];
            final float dy = y - last[1];

            if (onActionMove != null)
                onActionMove.onActionMove(dx, dy, ev);

            // Remember this touch position for the next move event
            last[0] = x;
            last[1] = y;

            break;
        }

        case MotionEvent.ACTION_UP: {
            mActivePointerId = MotionEvent.INVALID_POINTER_ID;
            if (onActionUp != null)
                onActionUp.onAction(ev);
            break;
        }

        case MotionEvent.ACTION_CANCEL: {
            mActivePointerId = MotionEvent.INVALID_POINTER_ID;
            break;
        }

        case MotionEvent.ACTION_POINTER_UP: {

            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;
                last[0] = MotionEventCompat.getX(ev, newPointerIndex);
                last[1] = MotionEventCompat.getY(ev, newPointerIndex);
                mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
            }
            if (onActionPointerUp != null)
                onActionPointerUp.onAction(ev);
            break;
        }
        }
    }
}

From source file:com.greenkee.pokeADot.GameActivity.java

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // tell system to use the layout defined in our XML file
    setContentView(com.greenkee.pokeADot.R.layout.activity_game_screen);

    mView = (GameView) findViewById(com.greenkee.pokeADot.R.id.gameScreen);
    mThread = mView.getThread();/*from w ww  .j  ava2s .c o m*/
    mView.setActivity(this);
    ((GameView) mView).setTextViews((TextView) findViewById(com.greenkee.pokeADot.R.id.status_display),
            (TextView) findViewById(com.greenkee.pokeADot.R.id.score_display),
            (TextView) findViewById(com.greenkee.pokeADot.R.id.combo_display));

    if (savedInstanceState == null) {
        System.out.println("STATE SET");
        mThread.doStart();
    } else {
        super.onRestoreInstanceState(savedInstanceState);
        mThread.restoreState(savedInstanceState);

    }
    mView.setOnTouchListener(new OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            int action = MotionEventCompat.getActionMasked(event);
            final int pointerIndex;
            final float x;
            final float y;
            switch (action) {
            case (MotionEvent.ACTION_DOWN): {
                //  System.out.println("ACTION_DOWN");
                if (((GameView.GameThread) mThread).getCurrentState() == GameView.GameThread.STATE_RUNNING) {
                    int index = MotionEventCompat.getActionIndex(event);
                    p1ID = MotionEventCompat.getPointerId(event, index);
                    if (p1ID != -1) {
                        int p1Index = MotionEventCompat.findPointerIndex(event, p1ID);
                        ((GameView.GameThread) mThread).checkTouch(MotionEventCompat.getX(event, p1Index),
                                MotionEventCompat.getY(event, p1Index));
                        //DO SOMETHING HERE

                    }
                } else if (!(mView.dialogOpen) && (!(((GameView.GameThread) mThread).gameOver))
                        && (((GameView.GameThread) mThread)
                                .getCurrentState() == GameView.GameThread.STATE_READY)
                        || (((GameView.GameThread) mThread)
                                .getCurrentState() == GameView.GameThread.STATE_LOSE)) {
                    ((GameView.GameThread) mThread).startGame();

                    // System.out.println("START GAME");

                } else if (((GameView.GameThread) mThread)
                        .getCurrentState() == GameView.GameThread.STATE_PAUSE) {
                    mThread.unpause();
                }

                return true;
            }
            case (MotionEvent.ACTION_MOVE): {
                //  System.out.println("ACTION_MOVE");
                if (((GameView.GameThread) mThread).getCurrentState() == GameView.GameThread.STATE_RUNNING) {
                    if (p1ID != -1) {
                        int p1Index = MotionEventCompat.findPointerIndex(event, p1ID);
                        //DO SOMETHING HERE

                    }
                }

                return true;
            }
            case (MotionEvent.ACTION_UP): {
                // System.out.println("ACTION_UP");

                reset();
                return true;
            }
            case (MotionEvent.ACTION_CANCEL): {
                // System.out.println("ACTION_CANCEL");
                reset();
                return true;
            }
            case (MotionEvent.ACTION_OUTSIDE): {
                return true;

            }
            }

            return false;
        }

        private void reset() {
            numTouches = 0;
            p1ID = -1;
            p2ID = -1;
        }
    }

    );
}

From source file:cn.goodjobs.common.view.photodraweeview.ScaleDragDetector.java

private void onTouchActivePointer(int action, MotionEvent ev) {
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = ev.getPointerId(0);
        break;/*from   ww  w. j a v a 2 s .c o  m*/
    case MotionEvent.ACTION_CANCEL:
    case MotionEvent.ACTION_UP:
        mActivePointerId = INVALID_POINTER_ID;
        break;
    case MotionEvent.ACTION_POINTER_UP:
        final int pointerIndex = MotionEventCompat.getActionIndex(ev);
        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        if (pointerId == mActivePointerId) {
            final int newPointerIndex = (pointerIndex == 0) ? 1 : 0;
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
            mLastTouchX = MotionEventCompat.getX(ev, newPointerIndex);
            mLastTouchY = MotionEventCompat.getY(ev, newPointerIndex);
        }

        break;
    }

    mActivePointerIndex = MotionEventCompat.findPointerIndex(ev,
            mActivePointerId != INVALID_POINTER_ID ? mActivePointerId : 0);
}

From source file:de.gobro.andreas.pa.pa_cleint_java.SendTouch.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);

    switch (action) {
    case MotionEvent.ACTION_DOWN: {
        Log.d("down", "action_down");
        break;/*from w  w  w .ja  v a  2s  .  com*/
    }
    case MotionEvent.ACTION_MOVE: {
        for (Integer i = 0; (i < ev.getPointerCount()) && (i < maxPoints); i++) {
            //final Integer pointerIndex = MotionEventCompat.getActionIndex(ev);

            Integer id = ev.getPointerId(i);
            Log.d("ind", "pinterindex" + i.toString());
            Log.d("ind", "ID" + id.toString());
            Log.d("pos", "(" + String.valueOf(MotionEventCompat.getX(ev, i)) + ";"
                    + String.valueOf(MotionEventCompat.getY(ev, i)) + ")");
            Log.d("test", "action_move");

            try {
                serializer.startTag("", "touch");
                serializer.startTag("", "dx");
                serializer.text(String.valueOf(MotionEventCompat.getX(ev, i) / size.x));
                serializer.endTag("", "dx");
                serializer.startTag("", "dy");
                serializer.text(String.valueOf(MotionEventCompat.getY(ev, i) / size.y));
                serializer.endTag("", "dy");
                serializer.startTag("", "id");
                serializer.text(id.toString());
                serializer.endTag("", "id");
                serializer.endTag("", "touch");

            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalStateException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (RuntimeException e) {
                e.printStackTrace();
            }

            //             try {
            //               writer.writeStartElement("touch");
            //                  writer.writeStartElement("dx");
            //                     writer.writeCharacters(String.valueOf(MotionEventCompat.getX(ev, i)/size.x));
            //                  writer.writeEndElement();
            //                  writer.writeStartElement("dy");
            //                     writer.writeCharacters(String.valueOf(MotionEventCompat.getY(ev, i)/size.y));
            //                  writer.writeEndElement();
            //                  writer.writeStartElement("id");
            //                     writer.writeCharacters(id.toString());
            //                  writer.writeEndElement();                  
            //               writer.writeEndElement();
            //            } catch (XMLStreamException e) {
            //               // TODO Auto-generated catch block
            //               e.printStackTrace();
            //            }

        }

        //write the stuff to the network
        try {
            serializer.flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            Toast.makeText(this, e.getMessage(), Toast.LENGTH_SHORT).show();
            finish();

        }
        break;
    }
    case MotionEvent.ACTION_UP: {
        Log.d("test", "action_up");
        break;
    }
    case MotionEvent.ACTION_CANCEL: {
        Log.d("test", "action_cancel");
        break;
    }
    case MotionEvent.ACTION_POINTER_DOWN: {
        Log.d("down", "action_p_down");
        break;
    }
    case MotionEvent.ACTION_POINTER_UP: {
        Log.d("test", "action_p_up");
        break;
    }
    }
    return true;
}

From source file:com.vincestyling.traversaless_testcase.TopTabIndicator.java

public boolean onTouchEvent(MotionEvent ev) {
    if (super.onTouchEvent(ev))
        return true;
    if (mViewPager == null)
        return false;

    final int count = getCount();
    if (count == 0)
        return false;

    final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mLastMotionX = ev.getX();/*  w  ww .  jav a  2  s  .  com*/
        break;

    case MotionEvent.ACTION_MOVE: {
        final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        final float x = MotionEventCompat.getX(ev, activePointerIndex);
        final float deltaX = x - mLastMotionX;

        if (!mIsDragging) {
            if (Math.abs(deltaX) > mTouchSlop) {
                mIsDragging = true;
            }
        }

        if (mIsDragging) {
            mLastMotionX = x;
            if (isFakeDragging() || beginFakeDrag()) {
                fakeDragBy(deltaX);
            }
        }

        break;
    }

    case MotionEvent.ACTION_CANCEL:
    case MotionEvent.ACTION_UP:
        if (!mIsDragging) {
            Rect areaRect = new Rect();
            areaRect.left = getPaddingLeft();
            areaRect.right = getWidth() - getPaddingRight();
            areaRect.top = getPaddingTop();
            areaRect.bottom = getHeight() - getPaddingBottom();

            int btnWidth = areaRect.width() / count;

            for (int pos = 0; pos < count; pos++) {
                RectF tabRect = new RectF(areaRect);
                tabRect.left += pos * btnWidth;
                tabRect.right = tabRect.left + btnWidth;

                if (tabRect.contains(ev.getX(), ev.getY())) {
                    setCurrentItem(pos);
                    return true;
                }
            }
        }

        mIsDragging = false;
        mActivePointerId = INVALID_POINTER;
        if (isFakeDragging())
            endFakeDrag();
        break;

    case MotionEventCompat.ACTION_POINTER_DOWN: {
        final int index = MotionEventCompat.getActionIndex(ev);
        mLastMotionX = MotionEventCompat.getX(ev, index);
        mActivePointerId = MotionEventCompat.getPointerId(ev, index);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        final int pointerIndex = MotionEventCompat.getActionIndex(ev);
        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        if (pointerId == mActivePointerId) {
            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
        }
        mLastMotionX = MotionEventCompat.getX(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId));
        break;
    }

    return true;
}

From source file:com.android.yijiang.kzx.widget.betterpickers.widget.UnderlinePageIndicatorPicker.java

public boolean onTouchEvent(MotionEvent ev) {
    if (super.onTouchEvent(ev)) {
        return true;
    }/*from ww  w.j a  v  a2  s . c om*/
    if ((mViewPager == null) || (mViewPager.getAdapter().getCount() == 0)) {
        return false;
    }

    final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mLastMotionX = ev.getX();
        break;

    case MotionEvent.ACTION_MOVE: {
        final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        final float x = MotionEventCompat.getX(ev, activePointerIndex);
        final float deltaX = x - mLastMotionX;

        if (!mIsDragging) {
            if (Math.abs(deltaX) > mTouchSlop) {
                mIsDragging = true;
            }
        }

        if (mIsDragging) {
            mLastMotionX = x;
            if (mViewPager.isFakeDragging() || mViewPager.beginFakeDrag()) {
                mViewPager.fakeDragBy(deltaX);
            }
        }

        break;
    }

    case MotionEvent.ACTION_CANCEL:
    case MotionEvent.ACTION_UP:
        if (!mIsDragging) {
            final int count = mViewPager.getAdapter().getCount();
            final int width = getWidth();
            final float halfWidth = width / 2f;
            final float sixthWidth = width / 6f;

            if ((mCurrentPage > 0) && (ev.getX() < halfWidth - sixthWidth)) {
                if (action != MotionEvent.ACTION_CANCEL) {
                    mViewPager.setCurrentItem(mCurrentPage - 1);
                }
                return true;
            } else if ((mCurrentPage < count - 1) && (ev.getX() > halfWidth + sixthWidth)) {
                if (action != MotionEvent.ACTION_CANCEL) {
                    mViewPager.setCurrentItem(mCurrentPage + 1);
                }
                return true;
            }
        }

        mIsDragging = false;
        mActivePointerId = INVALID_POINTER;
        if (mViewPager.isFakeDragging()) {
            mViewPager.endFakeDrag();
        }
        break;

    case MotionEventCompat.ACTION_POINTER_DOWN: {
        final int index = MotionEventCompat.getActionIndex(ev);
        mLastMotionX = MotionEventCompat.getX(ev, index);
        mActivePointerId = MotionEventCompat.getPointerId(ev, index);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        final int pointerIndex = MotionEventCompat.getActionIndex(ev);
        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        if (pointerId == mActivePointerId) {
            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
        }
        mLastMotionX = MotionEventCompat.getX(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId));
        break;
    }

    return true;
}

From source file:com.android.ex.photo.PhotoViewPager.java

/**
 * {@inheritDoc}//w w w  .  j  a v a2  s .c  o  m
 * <p>
 * We intercept touch event intercepts so we can prevent switching views when the
 * current view is internally scrollable.
 */
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    final InterceptType intercept = (mListener != null) ? mListener.onTouchIntercept(mActivatedX, mActivatedY)
            : InterceptType.NONE;
    final boolean ignoreScrollLeft = (intercept == InterceptType.BOTH || intercept == InterceptType.LEFT);
    final boolean ignoreScrollRight = (intercept == InterceptType.BOTH || intercept == InterceptType.RIGHT);

    // Only check ability to page if we can't scroll in one / both directions
    final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;

    if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
        mActivePointerId = INVALID_POINTER;
    }

    switch (action) {
    case MotionEvent.ACTION_MOVE: {
        if (ignoreScrollLeft || ignoreScrollRight) {
            final int activePointerId = mActivePointerId;
            if (activePointerId == INVALID_POINTER) {
                // If we don't have a valid id, the touch down wasn't on content.
                break;
            }

            final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
            final float x = MotionEventCompat.getX(ev, pointerIndex);

            if (ignoreScrollLeft && ignoreScrollRight) {
                mLastMotionX = x;
                return false;
            } else if (ignoreScrollLeft && (x > mLastMotionX)) {
                mLastMotionX = x;
                return false;
            } else if (ignoreScrollRight && (x < mLastMotionX)) {
                mLastMotionX = x;
                return false;
            }
        }
        break;
    }

    case MotionEvent.ACTION_DOWN: {
        mLastMotionX = ev.getX();
        // Use the raw x/y as the children can be located anywhere and there isn't a
        // single offset that would be meaningful
        mActivatedX = ev.getRawX();
        mActivatedY = ev.getRawY();
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP: {
        final int pointerIndex = MotionEventCompat.getActionIndex(ev);
        final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        if (pointerId == mActivePointerId) {
            // Our active pointer going up; select a new active pointer
            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
            mLastMotionX = MotionEventCompat.getX(ev, newPointerIndex);
            mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
        }
        break;
    }
    }

    return super.onInterceptTouchEvent(ev);
}