@Override public void transform(Canvas canvas, float currentFillPhase, View view) { canvas.clipRect(0, (view.getBottom() - view.getTop()) * (1f - currentFillPhase), view.getRight(), view.getBottom()); } }
void drawOverscrollHeader(Canvas canvas, Drawable drawable, Rect bounds) { final int height = drawable.getMinimumHeight(); canvas.save(); canvas.clipRect(bounds); final int span = bounds.bottom - bounds.top; if (span < height) { bounds.top = bounds.bottom - height; } drawable.setBounds(bounds); drawable.draw(canvas); canvas.restore(); }
void drawOverscrollFooter(Canvas canvas, Drawable drawable, Rect bounds) { final int height = drawable.getMinimumHeight(); canvas.save(); canvas.clipRect(bounds); final int span = bounds.bottom - bounds.top; if (span < height) { bounds.bottom = bounds.top + height; } drawable.setBounds(bounds); drawable.draw(canvas); canvas.restore(); }
@UiThread private void drawBackground(Canvas canvas, float fromX, float toX) { int count = canvas.save(); canvas.clipRect(fromX, (int) ((canvas.getHeight() - mStrokeWidth) / 2), toX, (int) ((canvas.getHeight() + mStrokeWidth) / 2)); mBackgroundDrawable.draw(canvas); canvas.restoreToCount(count); }
@Override public void draw(Canvas canvas) { if (mClip != null) { canvas.clipRect(mClip); mClip = null; } super.draw(canvas); }
@Override public void draw(Canvas canvas) { if (mClip != null) { canvas.clipRect(mClip); mClip = null; } super.draw(canvas); }
private void drawScrim(Canvas canvas, View child) { final int baseAlpha = (mScrimColor & 0xff000000) >>> 24; final int alpha = (int) (baseAlpha * mScrimOpacity); final int color = alpha << 24 | (mScrimColor & 0xffffff); if ((mTrackingEdge & EDGE_LEFT) != 0) { canvas.clipRect(0, 0, child.getLeft(), getHeight()); } else if ((mTrackingEdge & EDGE_RIGHT) != 0) { canvas.clipRect(child.getRight(), 0, getRight(), getHeight()); } else if ((mTrackingEdge & EDGE_BOTTOM) != 0) { canvas.clipRect(child.getLeft(), child.getBottom(), getRight(), getHeight()); } canvas.drawColor(color); }
@Override protected void drawZeroLine(Canvas c) { int clipRestoreCount = c.save(); mZeroLineClippingRect.set(mViewPortHandler.getContentRect()); mZeroLineClippingRect.inset(-mYAxis.getZeroLineWidth(), 0.f); c.clipRect(mLimitLineClippingRect); // draw zero line MPPointD pos = mTrans.getPixelForValues(0f, 0f); mZeroLinePaint.setColor(mYAxis.getZeroLineColor()); mZeroLinePaint.setStrokeWidth(mYAxis.getZeroLineWidth()); Path zeroLinePath = mDrawZeroLinePathBuffer; zeroLinePath.reset(); zeroLinePath.moveTo((float) pos.x - 1, mViewPortHandler.contentTop()); zeroLinePath.lineTo((float) pos.x - 1, mViewPortHandler.contentBottom()); // draw a path because lines don't support dashing on lower android versions c.drawPath(zeroLinePath, mZeroLinePaint); c.restoreToCount(clipRestoreCount); }
@Override public void draw(Canvas canvas) { if (mLayout == null) { return; } final int saveCount = canvas.save(); final Rect bounds = getBounds(); if (mClipToBounds) { canvas.clipRect(bounds); } canvas.translate(bounds.left, bounds.top + mLayoutTranslationY); mLayout.draw(canvas, getSelectionPath(), mHighlightPaint, 0); canvas.restoreToCount(saveCount); }
@Override public void draw(@NonNull Canvas canvas) { if (mInAnimation) { final int state = canvas.save(); int bottom = MathUtils.lerp(mBaseHeight, mHeight, mProgress); mRect.set(0, 0, mWidth, bottom); canvas.clipRect(mRect); super.draw(canvas); canvas.restoreToCount(state); } else { super.draw(canvas); } }
/** * Draws the zero line. */ protected void drawZeroLine(Canvas c) { int clipRestoreCount = c.save(); mZeroLineClippingRect.set(mViewPortHandler.getContentRect()); mZeroLineClippingRect.inset(0.f, -mYAxis.getZeroLineWidth()); c.clipRect(mZeroLineClippingRect); // draw zero line MPPointD pos = mTrans.getPixelForValues(0f, 0f); mZeroLinePaint.setColor(mYAxis.getZeroLineColor()); mZeroLinePaint.setStrokeWidth(mYAxis.getZeroLineWidth()); Path zeroLinePath = mDrawZeroLinePath; zeroLinePath.reset(); zeroLinePath.moveTo(mViewPortHandler.contentLeft(), (float) pos.y); zeroLinePath.lineTo(mViewPortHandler.contentRight(), (float) pos.y); // draw a path because lines don't support dashing on lower android versions c.drawPath(zeroLinePath, mZeroLinePaint); c.restoreToCount(clipRestoreCount); }
@Override public void draw(Canvas canvas) { if (mScreenWidth <= 0) return; final int saveCount = canvas.save(); canvas.translate(0, mTop); canvas.clipRect(0, -mTop, mScreenWidth, mTotalDragDistance); drawSky(canvas); drawSun(canvas); drawTown(canvas); canvas.restoreToCount(saveCount); }
@Override public void draw(Canvas canvas) { super.draw(canvas); if (lineCount == 1) { collapsingText.draw(canvas); } else { int savePoint = canvas.save(); float x = titleInsetStart; float y = Math.max(textTop - scrollOffset, titleInsetTop); canvas.translate(x, y); canvas.clipRect(0, 0, getWidth() - titleInsetStart - titleInsetEnd, Math.max(getHeight() - scrollOffset, collapsedHeight) - y); layout.draw(canvas); canvas.restoreToCount(savePoint); } }
@Override void drawLayer(Canvas canvas, Matrix parentMatrix, int parentAlpha) { L.beginSection("CompositionLayer#draw"); canvas.save(); newClipRect.set(0, 0, layerModel.getPreCompWidth(), layerModel.getPreCompHeight()); parentMatrix.mapRect(newClipRect); for (int i = layers.size() - 1; i >= 0 ; i--) { boolean nonEmptyClip = true; if (!newClipRect.isEmpty()) { nonEmptyClip = canvas.clipRect(newClipRect); } if (nonEmptyClip) { BaseLayer layer = layers.get(i); layer.draw(canvas, parentMatrix, parentAlpha); } } canvas.restore(); L.endSection("CompositionLayer#draw"); }
@Override public void renderGridLines(Canvas c) { if (!mXAxis.isDrawGridLinesEnabled() || !mXAxis.isEnabled()) return; int clipRestoreCount = c.save(); c.clipRect(getGridClippingRect()); if(mRenderGridLinesBuffer.length != mAxis.mEntryCount * 2){ mRenderGridLinesBuffer = new float[mXAxis.mEntryCount * 2]; } float[] positions = mRenderGridLinesBuffer; for (int i = 0; i < positions.length; i += 2) { positions[i] = mXAxis.mEntries[i / 2]; positions[i + 1] = mXAxis.mEntries[i / 2]; } mTrans.pointValuesToPixel(positions); setupGridPaint(); Path gridLinePath = mRenderGridLinesPath; gridLinePath.reset(); for (int i = 0; i < positions.length; i += 2) { drawGridLine(c, positions[i], positions[i + 1], gridLinePath); } c.restoreToCount(clipRestoreCount); }
@Override public void renderGridLines(Canvas c) { if (!mYAxis.isEnabled()) return; if (mYAxis.isDrawGridLinesEnabled()) { int clipRestoreCount = c.save(); c.clipRect(getGridClippingRect()); float[] positions = getTransformedPositions(); mGridPaint.setColor(mYAxis.getGridColor()); mGridPaint.setStrokeWidth(mYAxis.getGridLineWidth()); mGridPaint.setPathEffect(mYAxis.getGridDashPathEffect()); Path gridLinePath = mRenderGridLinesPath; gridLinePath.reset(); // draw the grid for (int i = 0; i < positions.length; i += 2) { // draw a path because lines don't support dashing on lower android versions c.drawPath(linePath(gridLinePath, i, positions), mGridPaint); gridLinePath.reset(); } c.restoreToCount(clipRestoreCount); } if (mYAxis.isDrawZeroLineEnabled()) { drawZeroLine(c); } }
private void testAndCheckGravity(int gravity, float currWidth, float currHeight, float translationX, float translationY) { TickerView.realignAndClipCanvasForGravity(canvas, gravity, viewBounds, currWidth, currHeight); verify(canvas).translate(translationX, translationY); verify(canvas).clipRect(0f, 0f, currWidth, currHeight); verifyNoMoreInteractions(canvas); }
/** * Draws the LimitLines associated with this axis to the screen. * * @param c */ @Override public void renderLimitLines(Canvas c) { List<LimitLine> limitLines = mXAxis.getLimitLines(); if (limitLines == null || limitLines.size() <= 0) return; float[] position = mRenderLimitLinesBuffer; position[0] = 0; position[1] = 0; for (int i = 0; i < limitLines.size(); i++) { LimitLine l = limitLines.get(i); if (!l.isEnabled()) continue; int clipRestoreCount = c.save(); mLimitLineClippingRect.set(mViewPortHandler.getContentRect()); mLimitLineClippingRect.inset(-l.getLineWidth(), 0.f); c.clipRect(mLimitLineClippingRect); position[0] = l.getLimit(); position[1] = 0.f; mTrans.pointValuesToPixel(position); renderLimitLineLine(c, l, position); renderLimitLineLabel(c, l, position, 2.f + l.getYOffset()); c.restoreToCount(clipRestoreCount); } }
private void draw(Canvas canvas, ImageView iv, Bitmap bm){ Matrix m = getMatrix(iv, bm); if(m != null){ int vpad = iv.getPaddingTop() + iv.getPaddingBottom(); int hpad = iv.getPaddingLeft() + iv.getPaddingRight(); if(vpad > 0 || hpad > 0){ canvas.clipRect(0, 0, iv.getWidth() - hpad, iv.getHeight() - vpad); } canvas.drawBitmap(bm, m, getPaint()); } if(!adjusted){ adjust(iv, bm, true); } }
@Override public void draw(Canvas canvas) { // We don't have access to the OverlayViewGroup instance directly, but we can manipulate // its Canvas via the Drawables' draw(). This allows us to draw outside the View bounds, // so we can position the margin overlays correctly. Rect newRect = canvas.getClipBounds(); // Make the Canvas Rect bigger according to the View margins. newRect.inset(-(mMargins.right + mMargins.left), -(mMargins.top + mMargins.bottom)); if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { canvas.clipRect(newRect, Region.Op.REPLACE); } else { canvas.clipOutRect(newRect); } super.draw(canvas); } }