@Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); View currentFocused = findFocus(); if (null == currentFocused || this == currentFocused) return; // If the currently-focused view was visible on the screen when the // screen was at the old height, then scroll the screen to make that // view visible with the new screen height. if (isWithinDeltaOfScreenV(currentFocused, 0, oldh)) { currentFocused.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(currentFocused, mTempRect); int scrollDelta = computeScrollDeltaToGetChildRectOnScreenV(mTempRect); doScrollY(scrollDelta); } final int maxJump = getRight() - getLeft(); if (isWithinDeltaOfScreenH(currentFocused, maxJump)) { currentFocused.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(currentFocused, mTempRect); int scrollDelta = computeScrollDeltaToGetChildRectOnScreenH(mTempRect); doScrollX(scrollDelta); } }
protected void draw(Canvas canvas) { canvas.save(); Path path = new Path(); outlinePaint.setStrokeWidth(outlineWidth); if (!hasFocus()) { outlinePaint.setColor(Color.BLACK); canvas.drawRect(drawRect, outlinePaint); } else { Rect viewDrawingRect = new Rect(); viewContext.getDrawingRect(viewDrawingRect); path.addRect(new RectF(drawRect), Path.Direction.CW); outlinePaint.setColor(highlightColor); if (isClipPathSupported(canvas)) { canvas.clipPath(path, Region.Op.DIFFERENCE); canvas.drawRect(viewDrawingRect, outsidePaint); } else { drawOutsideFallback(canvas); } canvas.restore(); canvas.drawPath(path, outlinePaint); if (showThirds) { drawThirds(canvas); } if (handleMode == HandleMode.Always || (handleMode == HandleMode.Changing && modifyMode == ModifyMode.Grow)) { drawHandles(canvas); } } }
/** * @return whether the descendant of this scroll view is within delta pixels of being on the * screen. */ private boolean isWithinDeltaOfScreen(View descendant, int delta, int height) { descendant.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(descendant, mTempRect); return (mTempRect.bottom + delta) >= getScrollY() && (mTempRect.top - delta) <= (getScrollY() + height); }
private boolean isWithinDeltaOfScreenH(View descendant, int delta) { descendant.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(descendant, mTempRect); return (mTempRect.right + delta) >= getScrollX() && (mTempRect.left - delta) <= (getScrollX() + getWidth()); }
private void drawLeftIndicator(Canvas canvas) { if (mLeftActiveView != null && isViewDescendant(mLeftActiveView)) { Integer position = (Integer) mLeftActiveView.getTag(R.id.tplActiveViewPosition); final int pos = position == null ? 0 : position; if (pos == mLeftActivePosition) { mLeftActiveView.getDrawingRect(mLeftActiveRect); offsetDescendantRectToMyCoords(mLeftActiveView, mLeftActiveRect); if (mLeftIndicatorAnimating) { final int indicatorFinalTop = mLeftActiveRect.top + ((mLeftActiveRect.height() - mLeftActiveIndicator.getHeight()) / 2); final int indicatorStartTop = mLeftIndicatorStartPos; final int diff = indicatorFinalTop - indicatorStartTop; final int startOffset = (int) (diff * mLeftIndicatorOffset); mLeftIndicatorTop = indicatorStartTop + startOffset; } else { mLeftIndicatorTop = mLeftActiveRect.top + ((mLeftActiveRect.height() - mLeftActiveIndicator.getHeight()) / 2); } final int right = (int) (mMiddlePane.getLeft() + Math.floor(mMiddlePane.getTranslationX())); final int left = right - mLeftActiveIndicator.getWidth(); canvas.save(); canvas.clipRect(left, 0, right, getHeight()); canvas.drawBitmap(mLeftActiveIndicator, left, mLeftIndicatorTop, null); canvas.restore(); } } }
private void scrollToChild(View var1) { var1.getDrawingRect(this.mTempRect); this.offsetDescendantRectToMyCoords(var1, this.mTempRect); int var2 = this.computeScrollDeltaToGetChildRectOnScreen(this.mTempRect); if (var2 != 0) { this.scrollBy(0, var2); } }
@Override public void requestChildFocus(View child, View focused) { super.requestChildFocus(child, focused); if (child != null) { Rect r = new Rect(); child.getDrawingRect(r); requestRectangleOnScreen(r); } }
/** * Scrolls the view to the given child. * * @param child the View to scroll to */ private void scrollToChild(View child) { child.getDrawingRect(mTempRect); /* Offset from child's local coordinates to TwoDScrollView coordinates */ offsetDescendantRectToMyCoords(child, mTempRect); int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect); if (scrollDelta != 0) { scrollBy(0, scrollDelta); } }
protected void onSizeChanged(int var1, int var2, int var3, int var4) { super.onSizeChanged(var1, var2, var3, var4); View var5 = this.findFocus(); if (var5 != null && this != var5 && this.isWithinDeltaOfScreen(var5, 0, var4)) { var5.getDrawingRect(this.mTempRect); this.offsetDescendantRectToMyCoords(var5, this.mTempRect); this.doScrollY(this.computeScrollDeltaToGetChildRectOnScreen(this.mTempRect)); } }
public boolean arrowScroll(int var1) { boolean var7 = false; View var9 = this.findFocus(); View var8 = var9; if (var9 == this) { var8 = null; } var9 = FocusFinder.getInstance().findNextFocus(this, var8, var1); int var4 = this.getMaxScrollAmount(); if (var9 != null && this.isWithinDeltaOfScreen(var9, var4, this.getHeight())) { var9.getDrawingRect(this.mTempRect); this.offsetDescendantRectToMyCoords(var9, this.mTempRect); this.doScrollY(this.computeScrollDeltaToGetChildRectOnScreen(this.mTempRect)); var9.requestFocus(var1); } else { int var2; if (var1 == 33 && this.getScrollY() < var4) { var2 = this.getScrollY(); } else { var2 = var4; if (var1 == 130) { var2 = var4; if (this.getChildCount() > 0) { int var5 = this.getChildAt(0).getBottom(); int var6 = this.getScrollY() + this.getHeight() - this.getPaddingBottom(); var2 = var4; if (var5 - var6 < var4) { var2 = var5 - var6; } } } } if (var2 == 0) { return var7; } if (var1 != 130) { var2 = -var2; } this.doScrollY(var2); } if (var8 != null && var8.isFocused() && this.isOffScreen(var8)) { var1 = this.getDescendantFocusability(); this.setDescendantFocusability(131072); this.requestFocus(); this.setDescendantFocusability(var1); } var7 = true; return var7; }
/** * Handle scrolling in response to an up or down arrow click. * * @param direction The direction corresponding to the arrow key that was pressed * @return True if we consumed the event, false otherwise */ public boolean arrowScroll(int direction) { View currentFocused = findFocus(); if (currentFocused == this) currentFocused = null; View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction); final int maxJump = getMaxScrollAmount(); if (nextFocused != null && isWithinDeltaOfScreen(nextFocused, maxJump, getHeight())) { nextFocused.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(nextFocused, mTempRect); int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect); doScrollY(scrollDelta); nextFocused.requestFocus(direction); } else { // no new focus int scrollDelta = maxJump; if (direction == View.FOCUS_UP && getScrollY() < scrollDelta) { scrollDelta = getScrollY(); } else if (direction == View.FOCUS_DOWN) { if (getChildCount() > 0) { int daBottom = getChildAt(0).getBottom(); int screenBottom = getScrollY() + getHeight(); if (daBottom - screenBottom < maxJump) { scrollDelta = daBottom - screenBottom; } } } if (scrollDelta == 0) { return false; } doScrollY(direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta); } if (currentFocused != null && currentFocused.isFocused() && isOffScreen(currentFocused)) { // previously focused item still has focus and is off screen, give // it up (take it back to ourselves) // (also, need to temporarily force FOCUS_BEFORE_DESCENDANTS so we // are // sure to // get it) final int descendantFocusability = getDescendantFocusability(); // save setDescendantFocusability(ViewGroup.FOCUS_BEFORE_DESCENDANTS); requestFocus(); setDescendantFocusability(descendantFocusability); // restore } return true; }
/** * Scrolls the view to the given child. * * @param child the View to scroll to */ private void scrollToChild(View child) { child.getDrawingRect(mTempRect); /* Offset from child's local coordinates to ScrollView coordinates */ offsetDescendantRectToMyCoords(child, mTempRect); int scrollDeltaV = computeScrollDeltaToGetChildRectOnScreenV(mTempRect); int scrollDeltaH = computeScrollDeltaToGetChildRectOnScreenH(mTempRect); if (scrollDeltaH != 0 || scrollDeltaV != 0) { scrollBy(scrollDeltaH, scrollDeltaV); } }
@Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { super.onSizeChanged(w, h, oldw, oldh); View currentFocused = findFocus(); if (null == currentFocused || this == currentFocused) return; // If the currently-focused view was visible on the screen when the // screen was at the old height, then scroll the screen to make that // view visible with the new screen height. currentFocused.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(currentFocused, mTempRect); int scrollDeltaX = computeScrollDeltaToGetChildRectOnScreen(mTempRect); int scrollDeltaY = computeScrollDeltaToGetChildRectOnScreen(mTempRect); doScroll(scrollDeltaX, scrollDeltaY); }
@Override public boolean onInterceptTouchEvent(MotionEvent ev) { if (mDragListener != null || mDropListener != null) { switch (ev.getAction()) { case MotionEvent.ACTION_DOWN: int x = (int) ev.getX(); int y = (int) ev.getY(); int itemnum = pointToPosition(x, y); if (itemnum == AdapterView.INVALID_POSITION) { break; } ViewGroup item = (ViewGroup) getChildAt(itemnum - getFirstVisiblePosition()); mDragPoint = y - item.getTop(); mCoordOffset = ((int) ev.getRawY()) - y; View dragger = item.findViewById(R.id.grabber); Rect r = mTempRect; dragger.getDrawingRect(r); // The dragger icon itself is quite small, so pretend the // touch area is bigger if (x < r.right * 2) { // Fix x position while dragging int[] itemPos = new int[2]; item.getLocationOnScreen(itemPos); item.setDrawingCacheEnabled(true); // Create a copy of the drawing cache so that it does // not get recycled // by the framework when the list tries to clean up // memory Bitmap bitmap = Bitmap.createBitmap(item.getDrawingCache()); startDragging(bitmap, itemPos[0], y); mDragPos = itemnum; mFirstDragPos = mDragPos; mHeight = getHeight(); int touchSlop = mTouchSlop; mUpperBound = Math.min(y - touchSlop, mHeight / 3); mLowerBound = Math.max(y + touchSlop, mHeight * 2 / 3); return false; } stopDragging(); break; } } return super.onInterceptTouchEvent(ev); }
@Override public void perform(UiController uiController, View view) { if (isDisplayingAtLeast(90).matches(view)) { Log.i(TAG, "View is already displayed. Returning."); return; } Rect rect = new Rect(); view.getDrawingRect(rect); if (!view.requestRectangleOnScreen(rect, true /* immediate */)) { Log.w(TAG, "Scrolling to view was requested, but none of the parents scrolled."); } uiController.loopMainThreadUntilIdle(); if (!isDisplayingAtLeast(90).matches(view)) { throw new PerformException.Builder() .withActionDescription(this.getDescription()) .withViewDescription(HumanReadables.describe(view)) .withCause( new RuntimeException( "Scrolling to view was attempted, but the view is not displayed")) .build(); } }
private void drawMiddleIndicator(Canvas canvas) { if (mMiddleActiveView != null && isViewDescendant(mMiddleActiveView)) { Integer position = (Integer) mMiddleActiveView.getTag(R.id.tplActiveViewPosition); final int pos = position == null ? 0 : position; if (pos == mMiddleActivePosition) { mMiddleActiveView.getDrawingRect(mMiddleActiveRect); offsetDescendantRectToMyCoords(mMiddleActiveView, mMiddleActiveRect); final float interpolatedRatio = 1.f - INDICATOR_INTERPOLATOR.getInterpolation(1.0f - mOffset); final int interpolatedWidth = (int) (mMiddleActiveIndicator.getWidth() * interpolatedRatio); if (mMiddleIndicatorAnimating) { final int indicatorFinalTop = mMiddleActiveRect.top + ((mMiddleActiveRect.height() - mMiddleActiveIndicator.getHeight()) / 2); final int indicatorStartTop = mMiddleIndicatorStartPos; final int diff = indicatorFinalTop - indicatorStartTop; final int startOffset = (int) (diff * mMiddleIndicatorOffset); mMiddleIndicatorTop = indicatorStartTop + startOffset; } else { mMiddleIndicatorTop = mMiddleActiveRect.top + ((mMiddleActiveRect.height() - mMiddleActiveIndicator.getHeight()) / 2); } final int right = (int) (mRightPane.getLeft() + mRightPane.getTranslationX()); final int left = right - interpolatedWidth; canvas.save(); canvas.clipRect(left, 0, right, getHeight()); canvas.drawBitmap(mMiddleActiveIndicator, left, mMiddleIndicatorTop, null); canvas.restore(); } } }
/* * Use to signal that there's a portion of this view that wants to be * visible to the user on the screen. This method will place the sub * view on the screen, and will also place as much of this view as possible * on the screen. If this view is smaller than the viewable area available, it * will be fully visible in addition to the subview. */ private void requestChildViewOnScreen(View child) { // Take focus so the user can be prepared to interact with this question, since // they will need to be fixing the input acceptFocus(); // Get the rectangle that wants to put itself on the screen Rect vitalPortion = new Rect(); child.getDrawingRect(vitalPortion); // Save a reference to it in case we have to manipulate it later. Rect vitalPortionSaved = new Rect(); child.getDrawingRect(vitalPortionSaved); // Then get the bounding rectangle for this whole view. Rect wholeView = new Rect(); this.getDrawingRect(wholeView); // If we don't know enough about the screen, just default to asking to see the // subview that was requested. if (mFrameHeight == -1) { child.requestRectangleOnScreen(vitalPortion); return; } // If the whole view fits, just request that we display the whole thing. if (wholeView.height() < mFrameHeight) { this.requestRectangleOnScreen(wholeView); return; } // The whole view will not fit, we need to scale down our requested focus. // Trying to construct the "ideal" rectangle here is actually pretty hard // but the base case is just to see if we can get the view onto the screen from // the bottom or the top int topY = wholeView.top; int bottomY = wholeView.bottom; // shrink the view to contain only the current frame size. wholeView.inset(0, (wholeView.height() - mFrameHeight) / 2); wholeView.offsetTo(wholeView.left, topY); // The view is now the size of the frame and anchored back at the top. // Now let's contextualize where the child view actually is in this frame. this.offsetDescendantRectToMyCoords(child, vitalPortion); // If the newly transformed view now contains the child portion, we're good if (wholeView.contains(vitalPortion)) { this.requestRectangleOnScreen(wholeView); return; } // otherwise, move to the requested frame to be at the bottom of this view wholeView.offsetTo(wholeView.left, bottomY - wholeView.height()); // now see if the transformed view contains the vital portion if (wholeView.contains(vitalPortion)) { this.requestRectangleOnScreen(wholeView); return; } // Otherwise the child is hidden in the frame, so it won't matter which // we choose. child.requestRectangleOnScreen(vitalPortionSaved); }
public boolean onTouch(View view, MotionEvent event) { float scale; final int X = (int) event.getRawX(); final int Y = (int) event.getRawY(); switch (event.getAction() & MotionEvent.ACTION_MASK) { case MotionEvent.ACTION_DOWN: view.setBackgroundResource(R.drawable.border); garbage.setVisibility(View.VISIBLE); RelativeLayout.LayoutParams lParams = (RelativeLayout.LayoutParams) view.getLayoutParams(); _xDelta = X - lParams.leftMargin; _yDelta = Y - lParams.topMargin; start.set(event.getX(), event.getY()); mode = DRAG; break; case MotionEvent.ACTION_UP: Iterator<View> iterator; mode = NONE; garbage.setVisibility(View.INVISIBLE); view.setBackgroundResource(R.color.none); if (event.getRawY() > 1530) { if (position_status == FRONT) { iterator = ViewList.iterator(); } else { iterator = ViewListBack.iterator(); } view.setVisibility(View.GONE); while (iterator.hasNext()) { View i = iterator.next(); if (i == view) { iterator.remove(); } } } break; case MotionEvent.ACTION_POINTER_DOWN: oldDist = spacing(event); if (oldDist > 8f) { RelativeLayout.LayoutParams zParams = (RelativeLayout.LayoutParams) view.getLayoutParams(); midPoint(mid, event); _xDelta = (int) mid.x - zParams.leftMargin; _yDelta = (int) mid.y - zParams.topMargin; mode = ZOOM; } break; case MotionEvent.ACTION_POINTER_UP: mode = NONE; break; case MotionEvent.ACTION_MOVE: RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) view.getLayoutParams(); if (mode == DRAG) { layoutParams.leftMargin = X - _xDelta; layoutParams.topMargin = Y - _yDelta; layoutParams.rightMargin = -250; layoutParams.bottomMargin = -250; view.setLayoutParams(layoutParams); rectView = new Rect(); view.getDrawingRect(rectView); if (event.getRawY() > 1530) { view.setBackgroundResource(R.color.deletecolor); } else view.setBackgroundResource(R.drawable.border); } else if (mode == ZOOM) { // pinch zooming float newDist = spacing(event); if (newDist > 8f) { // setting the scaling of the scale = newDist / oldDist; if (view instanceof ImageView) { int imgSizeH = view.getHeight(); int imgSizeW = view.getWidth(); imgSizeH = (int) (imgSizeH * scale); imgSizeW = (int) (imgSizeW * scale); layoutParams.width = imgSizeW; layoutParams.height = imgSizeH; layoutParams.leftMargin = (int) mid.x - _xDelta; layoutParams.topMargin = (int) mid.y - _yDelta; layoutParams.rightMargin = -250; layoutParams.bottomMargin = -250; view.setLayoutParams(layoutParams); } else if (view instanceof TextView) { // textSize = ((TextView) view).getTextSize(); textSize = textSize * scale; ((TextView) view).setTextSize(textSize); } oldDist = newDist; } } break; } mRrootLayout.invalidate(); return true; }
protected void draw(Canvas canvas) { if (mHidden) { return; } canvas.save(); Path path = new Path(); if (!hasFocus()) { mOutlinePaint.setColor(0xFF000000); canvas.drawRect(mDrawRect, mOutlinePaint); } else { Rect viewDrawingRect = new Rect(); mContext.getDrawingRect(viewDrawingRect); if (mCircle) { float width = mDrawRect.width(); float height = mDrawRect.height(); path.addCircle( mDrawRect.left + (width / 2), mDrawRect.top + (height / 2), width / 2, Path.Direction.CW); mOutlinePaint.setColor(0xFFEF04D6); } else { path.addRect(new RectF(mDrawRect), Path.Direction.CW); mOutlinePaint.setColor(0xFFFF8A00); } canvas.clipPath(path, Region.Op.DIFFERENCE); canvas.drawRect(viewDrawingRect, hasFocus() ? mFocusPaint : mNoFocusPaint); canvas.restore(); canvas.drawPath(path, mOutlinePaint); if (mMode == ModifyMode.Grow) { if (mCircle) { int width = mResizeDrawableDiagonal.getIntrinsicWidth(); int height = mResizeDrawableDiagonal.getIntrinsicHeight(); int d = (int) Math.round(Math.cos(/*45deg*/ Math.PI / 4D) * (mDrawRect.width() / 2D)); int x = mDrawRect.left + (mDrawRect.width() / 2) + d - width / 2; int y = mDrawRect.top + (mDrawRect.height() / 2) - d - height / 2; mResizeDrawableDiagonal.setBounds( x, y, x + mResizeDrawableDiagonal.getIntrinsicWidth(), y + mResizeDrawableDiagonal.getIntrinsicHeight()); mResizeDrawableDiagonal.draw(canvas); } else { int left = mDrawRect.left + 1; int right = mDrawRect.right + 1; int top = mDrawRect.top + 4; int bottom = mDrawRect.bottom + 3; int widthWidth = mResizeDrawableWidth.getIntrinsicWidth() / 2; int widthHeight = mResizeDrawableWidth.getIntrinsicHeight() / 2; int heightHeight = mResizeDrawableHeight.getIntrinsicHeight() / 2; int heightWidth = mResizeDrawableHeight.getIntrinsicWidth() / 2; int xMiddle = mDrawRect.left + ((mDrawRect.right - mDrawRect.left) / 2); int yMiddle = mDrawRect.top + ((mDrawRect.bottom - mDrawRect.top) / 2); mResizeDrawableWidth.setBounds( left - widthWidth, yMiddle - widthHeight, left + widthWidth, yMiddle + widthHeight); mResizeDrawableWidth.draw(canvas); mResizeDrawableWidth.setBounds( right - widthWidth, yMiddle - widthHeight, right + widthWidth, yMiddle + widthHeight); mResizeDrawableWidth.draw(canvas); mResizeDrawableHeight.setBounds( xMiddle - heightWidth, top - heightHeight, xMiddle + heightWidth, top + heightHeight); mResizeDrawableHeight.draw(canvas); mResizeDrawableHeight.setBounds( xMiddle - heightWidth, bottom - heightHeight, xMiddle + heightWidth, bottom + heightHeight); mResizeDrawableHeight.draw(canvas); } } } }
/** * Draw. * * @param canvas the canvas */ public void draw(Canvas canvas) { if (mHidden) { return; } canvas.save(); Path path = new Path(); if (!hasFocus()) { mOutlinePaint.setColor(0xFF000000); canvas.drawRect(mDrawRect, mOutlinePaint); } else { Rect viewDrawingRect = new Rect(); mContext.getDrawingRect(viewDrawingRect); if (mCircle) { float width = mDrawRect.width(); float height = mDrawRect.height(); path.addCircle( mDrawRect.left + (width / 2), mDrawRect.top + (height / 2), width / 2, Path.Direction.CW); mOutlinePaint.setColor(0xFFEF04D6); } else { path.addRect(new RectF(mDrawRect), Path.Direction.CW); mOutlinePaint.setColor(0xFFFF8A00); } Region region = new Region(); region.set(viewDrawingRect); region.op(mDrawRect, Region.Op.DIFFERENCE); RegionIterator iter = new RegionIterator(region); Rect r = new Rect(); while (iter.next(r)) { canvas.drawRect(r, hasFocus() ? mFocusPaint : mNoFocusPaint); } // android 4.0 Support bad.java.lang.UnsupportedOperationException // canvas.clipPath(path, Region.Op.DIFFERENCE); // canvas.drawRect(viewDrawingRect, hasFocus() ? mFocusPaint : mNoFocusPaint); canvas.restore(); canvas.drawPath(path, mOutlinePaint); if (mMode == ModifyMode.Grow) { if (mCircle) { int width = mResizeDrawableDiagonal.getIntrinsicWidth(); int height = mResizeDrawableDiagonal.getIntrinsicHeight(); int d = (int) Math.round(Math.cos(/* 45deg */ Math.PI / 4D) * (mDrawRect.width() / 2D)); int x = mDrawRect.left + (mDrawRect.width() / 2) + d - width / 2; int y = mDrawRect.top + (mDrawRect.height() / 2) - d - height / 2; mResizeDrawableDiagonal.setBounds( x, y, x + mResizeDrawableDiagonal.getIntrinsicWidth(), y + mResizeDrawableDiagonal.getIntrinsicHeight()); mResizeDrawableDiagonal.draw(canvas); } else { // int left = mDrawRect.left + 1; // int right = mDrawRect.right + 1; // int top = mDrawRect.top + 4; // int bottom = mDrawRect.bottom + 3; // // int widthWidth = mResizeDrawableWidth.getIntrinsicWidth() / 2; // int widthHeight = mResizeDrawableWidth.getIntrinsicHeight() / 2; // int heightHeight = mResizeDrawableHeight.getIntrinsicHeight() / 2; // int heightWidth = mResizeDrawableHeight.getIntrinsicWidth() / 2; // // int xMiddle = mDrawRect.left + ((mDrawRect.right - mDrawRect.left) / // 2); // int yMiddle = mDrawRect.top + ((mDrawRect.bottom - mDrawRect.top) / // 2); // // mResizeDrawableWidth.setBounds(left - widthWidth, yMiddle - // widthHeight, left + widthWidth, yMiddle // + widthHeight); // mResizeDrawableWidth.draw(canvas); // // mResizeDrawableWidth.setBounds(right - widthWidth, yMiddle - // widthHeight, right + widthWidth, yMiddle // + widthHeight); // mResizeDrawableWidth.draw(canvas); // // mResizeDrawableHeight.setBounds(xMiddle - heightWidth, top - // heightHeight, xMiddle + heightWidth, top // + heightHeight); // mResizeDrawableHeight.draw(canvas); // // mResizeDrawableHeight.setBounds(xMiddle - heightWidth, bottom - // heightHeight, xMiddle + heightWidth, bottom // + heightHeight); // mResizeDrawableHeight.draw(canvas); } } if (mCircle) { } else { int left = mDrawRect.left + 1; int right = mDrawRect.right + 1; int top = mDrawRect.top + 4; int bottom = mDrawRect.bottom + 3; int widthWidth = mResizeDrawableDiagonal.getIntrinsicWidth() / 2; int widthHeight = mResizeDrawableDiagonal.getIntrinsicHeight() / 2; mResizeDrawableDiagonal2.setBounds( left - widthWidth, top - widthHeight, left + widthWidth, top + widthHeight); mResizeDrawableDiagonal2.draw(canvas); mResizeDrawableDiagonal.setBounds( right - widthWidth, top - widthHeight, right + widthWidth, top + widthHeight); mResizeDrawableDiagonal.draw(canvas); mResizeDrawableDiagonal.setBounds( left - widthWidth, bottom - widthHeight, left + widthWidth, bottom + widthHeight); mResizeDrawableDiagonal.draw(canvas); mResizeDrawableDiagonal2.setBounds( right - widthWidth, bottom - widthHeight, right + widthWidth, bottom + widthHeight); mResizeDrawableDiagonal2.draw(canvas); } } }
private boolean isWithinDeltaOfScreen(View var1, int var2, int var3) { var1.getDrawingRect(this.mTempRect); this.offsetDescendantRectToMyCoords(var1, this.mTempRect); return this.mTempRect.bottom + var2 >= this.getScrollY() && this.mTempRect.top - var2 <= this.getScrollY() + var3; }
/** * Handle scrolling in response to an up or down arrow click. * * @param direction The direction corresponding to the arrow key that was pressed * @return True if we consumed the event, false otherwise */ public boolean arrowScroll(int direction, boolean horizontal) { View currentFocused = findFocus(); if (currentFocused == this) currentFocused = null; View nextFocused = FocusFinder.getInstance().findNextFocus(this, currentFocused, direction); final int maxJump = horizontal ? getMaxScrollAmountHorizontal() : getMaxScrollAmountVertical(); if (!horizontal) { if (nextFocused != null) { nextFocused.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(nextFocused, mTempRect); int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect); doScroll(0, scrollDelta); nextFocused.requestFocus(direction); } else { // no new focus int scrollDelta = maxJump; if (direction == View.FOCUS_UP && getScrollY() < scrollDelta) { scrollDelta = getScrollY(); } else if (direction == View.FOCUS_DOWN) { if (getChildCount() > 0) { int daBottom = getChildAt(0).getBottom(); int screenBottom = getScrollY() + getHeight(); if (daBottom - screenBottom < maxJump) { scrollDelta = daBottom - screenBottom; } } } if (scrollDelta == 0) { return false; } doScroll(0, direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta); } } else { if (nextFocused != null) { nextFocused.getDrawingRect(mTempRect); offsetDescendantRectToMyCoords(nextFocused, mTempRect); int scrollDelta = computeScrollDeltaToGetChildRectOnScreen(mTempRect); doScroll(scrollDelta, 0); nextFocused.requestFocus(direction); } else { // no new focus int scrollDelta = maxJump; if (direction == View.FOCUS_UP && getScrollY() < scrollDelta) { scrollDelta = getScrollY(); } else if (direction == View.FOCUS_DOWN) { if (getChildCount() > 0) { int daBottom = getChildAt(0).getBottom(); int screenBottom = getScrollY() + getHeight(); if (daBottom - screenBottom < maxJump) { scrollDelta = daBottom - screenBottom; } } } if (scrollDelta == 0) { return false; } doScroll(direction == View.FOCUS_DOWN ? scrollDelta : -scrollDelta, 0); } } return true; }