コード例 #1
0
 @Override
 public void getItemOffsets(
     Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
   if (parent.getChildPosition(view) != 0) {
     outRect.left = devideSpace;
   }
 }
コード例 #2
0
  @Override
  public boolean onInterceptTouchEvent(RecyclerView view, MotionEvent event) {
    childView = view.findChildViewUnder(event.getX(), event.getY());
    childViewPosition = view.getChildPosition(childView);

    return childView != null && gestureDetector.onTouchEvent(event);
  }
コード例 #3
0
ファイル: DragSortRecycler.java プロジェクト: jsveiga/Slide
  @Override
  public void getItemOffsets(Rect outRect, View view, RecyclerView rv, RecyclerView.State state) {
    super.getItemOffsets(outRect, view, rv, state);

    debugLog("getItemOffsets");

    debugLog("View top = " + view.getTop());
    if (selectedDragItemPos != -1) {
      int itemPos = rv.getChildPosition(view);
      debugLog("itemPos =" + itemPos);

      if (!canDragOver(itemPos)) {
        return;
      }

      // Movement of finger
      float totalMovement = fingerY - fingerAnchorY;

      if (itemPos == selectedDragItemPos) {
        view.setVisibility(View.INVISIBLE);
      } else {
        // Make view visible incase invisible
        view.setVisibility(View.VISIBLE);

        // Find middle of the floatingItem
        float floatMiddleY = floatingItemBounds.top + floatingItemBounds.height() / 2;

        // Moving down the list
        // These will auto-animate if the device continually sends touch motion events
        // if (totalMovment>0)
        {
          if ((itemPos > selectedDragItemPos) && (view.getTop() < floatMiddleY)) {
            float amountUp = (floatMiddleY - view.getTop()) / (float) view.getHeight();
            //  amountUp *= 0.5f;
            if (amountUp > 1) amountUp = 1;

            outRect.top = -(int) (floatingItemBounds.height() * amountUp);
            outRect.bottom = (int) (floatingItemBounds.height() * amountUp);
          }
        } // Moving up the list
        // else if (totalMovment < 0)
        {
          if ((itemPos < selectedDragItemPos) && (view.getBottom() > floatMiddleY)) {
            float amountDown = ((float) view.getBottom() - floatMiddleY) / (float) view.getHeight();
            //  amountDown *= 0.5f;
            if (amountDown > 1) amountDown = 1;

            outRect.top = (int) (floatingItemBounds.height() * amountDown);
            outRect.bottom = -(int) (floatingItemBounds.height() * amountDown);
          }
        }
      }
    } else {
      outRect.top = 0;
      outRect.bottom = 0;
      // Make view visible incase invisible
      view.setVisibility(View.VISIBLE);
    }
  }
コード例 #4
0
 private void updateOnScreenCheckedViews() {
   final int count = mRecyclerView.getChildCount();
   for (int i = 0; i < count; i++) {
     final View child = mRecyclerView.getChildAt(i);
     final int position = mRecyclerView.getChildPosition(child);
     setViewChecked(child, mCheckedStates.get(position));
   }
 }
コード例 #5
0
ファイル: FragmentDrawer.java プロジェクト: phamnoone/owsdic
 @Override
 public boolean onInterceptTouchEvent(RecyclerView rv, MotionEvent e) {
   View child = rv.findChildViewUnder(e.getX(), e.getY());
   if (child != null && clickListener != null && gestureDetector.onTouchEvent(e)) {
     clickListener.onClick(child, rv.getChildPosition(child));
   }
   return false;
 }
コード例 #6
0
 @Override
 public boolean onInterceptTouchEvent(RecyclerView view, MotionEvent e) {
   View childView = view.findChildViewUnder(e.getX(), e.getY());
   if (childView != null && mListener != null && mGestureDetector.onTouchEvent(e)) {
     mListener.onItemClick(childView, view.getChildPosition(childView));
   }
   return false;
 }
コード例 #7
0
 public void addViewToActionMode(final View view) {
   if (mActionMode == null) {
     mActionMode = mActivity.startSupportActionMode(this);
   }
   final int position = mRecyclerView.getChildPosition(view);
   if (!mActivatedPositions.contains(position)) {
     toggleViewActivatedState(view);
   }
 }
コード例 #8
0
 @Override
 public boolean onInterceptTouchEvent(RecyclerView rv, MotionEvent event) {
   View child = rv.findChildViewUnder(event.getX(), event.getY());
   if (null != child && null != clickListener && gestureDetector.onTouchEvent(event)) {
     child.onTouchEvent(event);
     clickListener.onClick(child, rv.getChildPosition(child));
   }
   return false;
 }
コード例 #9
0
 @Override
 public boolean onInterceptTouchEvent(android.support.v7.widget.RecyclerView rv, MotionEvent e) {
   View child = rv.findChildViewUnder(e.getX(), e.getY());
   RecyclerView.ViewHolder finalChild =
       rv.findViewHolderForAdapterPosition(rv.getChildAdapterPosition(child));
   if (child != null && clickListener != null && gestureDetector.onTouchEvent(e) == true) {
     clickListener.onClick(finalChild, rv.getChildPosition(child));
   }
   return false;
 }
コード例 #10
0
  @Override
  public void getItemOffsets(
      Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
    if (mLeftSpace != -1) outRect.left = (int) mLeftSpace;

    if (mRightSpace != -1) outRect.right = (int) mRightSpace;

    if (mBottomSpace != -1) outRect.bottom = (int) mBottomSpace;

    // Add top margin only for the first item to avoid double space between items
    if (parent.getChildPosition(view) == 0 && mTopSpace != -1) outRect.top = (int) mTopSpace;
  }
コード例 #11
0
  /*
   *  Detects touch/motion event and fires click listener if onSingleTapUp return true.
   */
  @Override
  public boolean onInterceptTouchEvent(RecyclerView view, MotionEvent event) {

    /*
     *  We get the recycler item view on that position because we can't get the view by the index position
     *  due to the logic of the recycler view... because it recycles views...
     */
    View item = view.findChildViewUnder(event.getX(), event.getY());
    int res = this.getResult(event);
    if (item != null && res != PairedDeviceItemClickListener.GESTURE_NONE) {

      /*
       *  We handle each event.
       */
      if (res == PairedDeviceItemClickListener.GESTURE_TAP_UP) {
        this.listener.onItemClick(item, view.getChildPosition(item));
      } else if (res == PairedDeviceItemClickListener.GESTURE_LONG_PRESS) {
        this.listener.onItemLongClick(item, view.getChildPosition(item));
      }
    }
    return false;
  }
コード例 #12
0
  @Override
  public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
    super.onScrollStateChanged(recyclerView, newState);

    LinearLayoutManager lm = (LinearLayoutManager) recyclerView.getLayoutManager();

    if (mCenterPivot == 0) {

      mCenterPivot =
          lm.getOrientation() == LinearLayoutManager.HORIZONTAL
              ? (recyclerView.getLeft() + recyclerView.getRight())
              : (recyclerView.getTop() + recyclerView.getBottom());
    }
    if (!mAutoSet) {

      if (newState == RecyclerView.SCROLL_STATE_IDLE) {

        View view = findCenterView(lm);

        int position = recyclerView.getChildPosition(view);

        Log.i("CenterLockListener", "list-position" + position);

        Toast.makeText(context, "list-position" + position, Toast.LENGTH_SHORT).show();

        int viewCenter =
            lm.getOrientation() == LinearLayoutManager.HORIZONTAL
                ? (view.getLeft() + view.getRight()) / 2
                : (view.getTop() + view.getBottom()) / 2;

        int scrollNeeded = viewCenter - mCenterPivot;

        if (lm.getOrientation() == LinearLayoutManager.HORIZONTAL) {

          recyclerView.smoothScrollBy(scrollNeeded, 0);
        } else {
          recyclerView.smoothScrollBy(0, (int) (scrollNeeded));
        }
        mAutoSet = true;
      }
    }
    if (newState == RecyclerView.SCROLL_STATE_DRAGGING
        || newState == RecyclerView.SCROLL_STATE_SETTLING) {

      mAutoSet = false;
    }
  }
コード例 #13
0
  @Override
  public void getItemOffsets(
      Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
    super.getItemOffsets(outRect, view, parent, state);
    if (mDivider == null) {
      return;
    }
    if (parent.getChildPosition(view) < 1) {
      return;
    }

    if (getOrientation(parent) == LinearLayoutManager.VERTICAL) {
      outRect.top = mDivider.getIntrinsicHeight();
    } else {
      outRect.left = mDivider.getIntrinsicWidth();
    }
  }
コード例 #14
0
  private void toggleViewActivatedState(final View view) {
    final int position = mRecyclerView.getChildPosition(view);
    if (position == RecyclerView.NO_POSITION) {
      return;
    }

    if (mSelectionMode == SelectionMode.SINGLE) {
      final boolean checked = mActivatedPositions.contains(position);
      view.setActivated(!checked);
      mRecyclerView.getAdapter().notifyItemChanged(position);

      if (mActivatedPositions.size() > 0) {
        final int previous = mActivatedPositions.iterator().next();
        mActivatedPositions.remove(previous);
        mRecyclerView.getAdapter().notifyItemChanged(previous);
      }

      if (checked) {
        mActivatedPositions.remove(position);
      } else {
        mActivatedPositions.add(position);
      }
      onCheckedStateChanged(mActionMode, position, !checked);

      if (mActivatedPositions.isEmpty()) {
        finish();
      }
    } else if (mSelectionMode == SelectionMode.MULTIPLE) {
      final boolean checked = mActivatedPositions.contains(position);
      view.setActivated(!checked);
      mRecyclerView.getAdapter().notifyItemChanged(position);

      if (checked) {
        mActivatedPositions.remove(position);
      } else {
        mActivatedPositions.add(position);
      }
      onCheckedStateChanged(mActionMode, position, !checked);

      if (mActivatedPositions.isEmpty()) {
        finish();
      }
    }
  }
コード例 #15
0
ファイル: DragSortRecycler.java プロジェクト: jsveiga/Slide
  /**
   * Find the new position by scanning through the items on screen and finding the positional
   * relationship. This *seems* to work, another method would be to use getItemOffsets, but I think
   * that could miss items?..
   */
  private int getNewPostion(RecyclerView rv) {
    int itemsOnScreen = rv.getLayoutManager().getChildCount();

    float floatMiddleY = floatingItemBounds.top + floatingItemBounds.height() / 2;

    int above = 0;
    int below = Integer.MAX_VALUE;
    for (int n = 0; n < itemsOnScreen; n++) // Scan though items on screen, however they may not
    { // be in order!

      View view = rv.getLayoutManager().getChildAt(n);

      if (view.getVisibility() != View.VISIBLE) continue;

      int itemPos = rv.getChildPosition(view);

      if (itemPos == selectedDragItemPos) // Don't check against itself!
      continue;

      float viewMiddleY = view.getTop() + view.getHeight() / 2;
      if (floatMiddleY > viewMiddleY) // Is above this item
      {
        if (itemPos > above) above = itemPos;
      } else if (floatMiddleY <= viewMiddleY) // Is below this item
      {
        if (itemPos < below) below = itemPos;
      }
    }
    debugLog("above = " + above + " below = " + below);

    if (below != Integer.MAX_VALUE) {
      if (below < selectedDragItemPos) // Need to count itself
      below++;
      return below - 1;
    } else {
      if (above < selectedDragItemPos) above++;

      return above;
    }
  }
コード例 #16
0
  public void update(RecyclerView referenceList, float dx, float dy) {
    if (indexList != null && indexList.getChildCount() > 2) {
      show();
      updatePosBasedOnReferenceList(referenceList);

      View firstVisibleView = indexList.getChildAt(0);
      View secondVisibleView = indexList.getChildAt(1);

      TextView firstRowIndex = (TextView) firstVisibleView.findViewById(R.id.section_title);
      TextView secondRowIndex = (TextView) secondVisibleView.findViewById(R.id.section_title);

      int visibleRange = indexList.getChildCount();
      int actual = indexList.getChildPosition(firstVisibleView);
      int next = actual + 1;
      int last = actual + visibleRange;

      // RESET STICKY LETTER INDEX
      stickyIndex.setText(String.valueOf(getIndexContext(firstRowIndex)).toUpperCase());
      stickyIndex.setVisibility(TextView.VISIBLE);
      ViewCompat.setAlpha(firstRowIndex, 1);

      if (dy > 0) {
        // USER SCROLLING DOWN THE RecyclerView
        if (next <= last) {
          if (isHeader(firstRowIndex, secondRowIndex)) {
            stickyIndex.setVisibility(TextView.INVISIBLE);
            firstRowIndex.setVisibility(TextView.VISIBLE);
            ViewCompat.setAlpha(
                firstRowIndex,
                (1 - (Math.abs(ViewCompat.getY(firstVisibleView)) / firstRowIndex.getHeight())));
            secondRowIndex.setVisibility(TextView.VISIBLE);
          } else {
            firstRowIndex.setVisibility(TextView.INVISIBLE);
            stickyIndex.setVisibility(TextView.VISIBLE);
          }
        }
      } else if (dy < 0) {
        // USER IS SCROLLING UP THE RecyclerVIew
        if (next <= last) {
          // RESET FIRST ROW STATE
          firstRowIndex.setVisibility(TextView.INVISIBLE);
          if ((isHeader(firstRowIndex, secondRowIndex)
                  || (getIndexContext(firstRowIndex) != getIndexContext(secondRowIndex)))
              && isHeader(firstRowIndex, secondRowIndex)) {
            stickyIndex.setVisibility(TextView.INVISIBLE);
            firstRowIndex.setVisibility(TextView.VISIBLE);
            ViewCompat.setAlpha(
                firstRowIndex,
                1 - (Math.abs(ViewCompat.getY(firstVisibleView) / firstRowIndex.getHeight())));
            secondRowIndex.setVisibility(TextView.VISIBLE);
          } else {
            secondRowIndex.setVisibility(TextView.INVISIBLE);
          }
        }
      }

      if (stickyIndex.getVisibility() == TextView.VISIBLE) {
        firstRowIndex.setVisibility(TextView.INVISIBLE);
      }
    } else {
      hide();
    }
  }
コード例 #17
0
 @Override
 public void getItemOffsets(
     Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
   outRect.right = space;
   if (parent.getChildPosition(view) == 0) outRect.left = space;
 }
コード例 #18
0
  private boolean handleTouchEvent(MotionEvent motionEvent) {
    if (mViewWidth < 2) {
      mViewWidth = mRecyclerView.getWidth();
    }

    switch (motionEvent.getActionMasked()) {
      case MotionEvent.ACTION_DOWN:
        {
          if (mPaused) {
            break;
          }

          // Find the child view that was touched (perform a hit test)
          Rect rect = new Rect();
          int childCount = mRecyclerView.getChildCount();
          int[] listViewCoords = new int[2];
          mRecyclerView.getLocationOnScreen(listViewCoords);
          int x = (int) motionEvent.getRawX() - listViewCoords[0];
          int y = (int) motionEvent.getRawY() - listViewCoords[1];
          View child;
          for (int i = 0; i < childCount; i++) {
            child = mRecyclerView.getChildAt(i);
            child.getHitRect(rect);
            if (rect.contains(x, y)) {
              mDownView = child;
              break;
            }
          }

          if (mDownView != null
              && mAnimatingPosition != mRecyclerView.getChildPosition(mDownView)) {
            mAlpha = mDownView.getAlpha();
            mDownX = motionEvent.getRawX();
            mDownY = motionEvent.getRawY();
            mDownPosition = mRecyclerView.getChildPosition(mDownView);
            if (mSwipeListener.canSwipe(mDownPosition)) {
              mVelocityTracker = VelocityTracker.obtain();
              mVelocityTracker.addMovement(motionEvent);
            } else {
              mDownView = null;
            }
          }
          break;
        }

      case MotionEvent.ACTION_CANCEL:
        {
          if (mVelocityTracker == null) {
            break;
          }

          if (mDownView != null && mSwiping) {
            // cancel
            mDownView
                .animate()
                .translationX(0)
                .alpha(mAlpha)
                .setDuration(mAnimationTime)
                .setListener(null);
          }
          mVelocityTracker.recycle();
          mVelocityTracker = null;
          mDownX = 0;
          mDownY = 0;
          mDownView = null;
          mDownPosition = ListView.INVALID_POSITION;
          mSwiping = false;
          break;
        }

      case MotionEvent.ACTION_UP:
        {
          if (mVelocityTracker == null) {
            break;
          }

          mFinalDelta = motionEvent.getRawX() - mDownX;
          mVelocityTracker.addMovement(motionEvent);
          mVelocityTracker.computeCurrentVelocity(1000);
          float velocityX = mVelocityTracker.getXVelocity();
          float absVelocityX = Math.abs(velocityX);
          float absVelocityY = Math.abs(mVelocityTracker.getYVelocity());
          boolean dismiss = false;
          boolean dismissRight = false;
          if (Math.abs(mFinalDelta) > mViewWidth / 2 && mSwiping) {
            dismiss = true;
            dismissRight = mFinalDelta > 0;
          } else if (mMinFlingVelocity <= absVelocityX
              && absVelocityX <= mMaxFlingVelocity
              && absVelocityY < absVelocityX
              && mSwiping) {
            // dismiss only if flinging in the same direction as dragging
            dismiss = (velocityX < 0) == (mFinalDelta < 0);
            dismissRight = mVelocityTracker.getXVelocity() > 0;
          }
          if (dismiss
              && mDownPosition != mAnimatingPosition
              && mDownPosition != ListView.INVALID_POSITION) {
            // dismiss
            final View downView = mDownView; // mDownView gets null'd before animation ends
            final int downPosition = mDownPosition;
            ++mDismissAnimationRefCount;
            mAnimatingPosition = mDownPosition;
            mDownView
                .animate()
                .translationX(dismissRight ? mViewWidth : -mViewWidth)
                .alpha(0)
                .setDuration(mAnimationTime)
                .setListener(
                    new AnimatorListenerAdapter() {
                      @Override
                      public void onAnimationEnd(Animator animation) {
                        performDismiss(downView, downPosition);
                      }
                    });
          } else {
            // cancel
            mDownView
                .animate()
                .translationX(0)
                .alpha(mAlpha)
                .setDuration(mAnimationTime)
                .setListener(null);
          }
          mVelocityTracker.recycle();
          mVelocityTracker = null;
          mDownX = 0;
          mDownY = 0;
          mDownView = null;
          mDownPosition = ListView.INVALID_POSITION;
          mSwiping = false;
          break;
        }

      case MotionEvent.ACTION_MOVE:
        {
          if (mVelocityTracker == null || mPaused) {
            break;
          }

          mVelocityTracker.addMovement(motionEvent);
          float deltaX = motionEvent.getRawX() - mDownX;
          float deltaY = motionEvent.getRawY() - mDownY;
          if (!mSwiping && Math.abs(deltaX) > mSlop && Math.abs(deltaY) < Math.abs(deltaX) / 2) {
            mSwiping = true;
            mSwipingSlop = (deltaX > 0 ? mSlop : -mSlop);
          }

          if (mSwiping) {
            mDownView.setTranslationX(deltaX - mSwipingSlop);
            mDownView.setAlpha(
                Math.max(0f, Math.min(mAlpha, mAlpha * (1f - Math.abs(deltaX) / mViewWidth))));
            return true;
          }
          break;
        }
    }

    return false;
  }
コード例 #19
0
ファイル: DragSortRecycler.java プロジェクト: jsveiga/Slide
  @Override
  public boolean onInterceptTouchEvent(RecyclerView rv, MotionEvent e) {
    debugLog("onInterceptTouchEvent");

    // if (e.getAction() == MotionEvent.ACTION_DOWN)
    {
      View itemView = rv.findChildViewUnder(e.getX(), e.getY());

      if (itemView == null) return false;

      boolean dragging = false;

      if ((dragHandleWidth > 0) && (e.getX() < dragHandleWidth)) {
        dragging = true;
      } else if (viewHandleId != -1) {
        // Find the handle in the list item
        View handleView = itemView.findViewById(viewHandleId);

        if (handleView == null) {
          Log.e(TAG, "The view ID " + viewHandleId + " was not found in the RecycleView item");
          return false;
        }

        // View should be visible to drag
        if (handleView.getVisibility() != View.VISIBLE) {
          return false;
        }

        // We need to find the relative position of the handle to the parent view
        // Then we can work out if the touch is within the handle
        int[] parentItemPos = new int[2];
        itemView.getLocationInWindow(parentItemPos);

        int[] handlePos = new int[2];
        handleView.getLocationInWindow(handlePos);

        int xRel = handlePos[0] - parentItemPos[0];
        int yRel = handlePos[1] - parentItemPos[1];

        Rect touchBounds =
            new Rect(
                itemView.getLeft() + xRel,
                itemView.getTop() + yRel,
                itemView.getLeft() + xRel + handleView.getWidth(),
                itemView.getTop() + yRel + handleView.getHeight());

        if (touchBounds.contains((int) e.getX(), (int) e.getY())) dragging = true;

        debugLog("parentItemPos = " + parentItemPos[0] + " " + parentItemPos[1]);
        debugLog("handlePos = " + handlePos[0] + " " + handlePos[1]);
      }

      if (dragging) {
        debugLog("Started Drag");

        setIsDragging(true);

        floatingItem = createFloatingBitmap(itemView);

        fingerAnchorY = (int) e.getY();
        fingerOffsetInViewY = fingerAnchorY - itemView.getTop();
        fingerY = fingerAnchorY;

        selectedDragItemPos = rv.getChildPosition(itemView);
        debugLog("selectedDragItemPos = " + selectedDragItemPos);

        return true;
      }
    }
    return false;
  }
コード例 #20
0
 private void updatePosBasedOnReferenceList(RecyclerView referenceRv) {
   View firstVisibleView = referenceRv.getChildAt(0);
   int actual = referenceRv.getChildPosition(firstVisibleView);
   ((LinearLayoutManager) indexList.getLayoutManager())
       .scrollToPositionWithOffset(actual, firstVisibleView.getTop() + 0);
 }