/** * Drawing src bitmap to dest bitmap with applied mask. * * @param src source bitmap * @param mask bitmap mask * @param dest destination bitmap * @param clearColor clear color */ public static void drawMasked(Bitmap src, Drawable mask, Bitmap dest, int clearColor) { clearBitmap(dest, clearColor); Canvas canvas = new Canvas(dest); canvas.drawBitmap( src, new Rect(0, 0, src.getWidth(), src.getHeight()), new Rect(0, 0, dest.getWidth(), dest.getHeight()), new Paint(Paint.FILTER_BITMAP_FLAG)); if (mask instanceof BitmapDrawable) { ((BitmapDrawable) mask) .getPaint() .setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); } else if (mask instanceof NinePatchDrawable) { ((NinePatchDrawable) mask) .getPaint() .setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); } else { throw new RuntimeException("Supported only BitmapDrawable or NinePatchDrawable"); } mask.setBounds(0, 0, mask.getIntrinsicWidth(), mask.getIntrinsicHeight()); mask.draw(canvas); canvas.setBitmap(null); }
/** * Drawing src bitmap to dest bitmap with rounded corners * * @param src source bitmap * @param dest destination bitmap * @param radius radius in destination bitmap scale * @param clearColor clear color */ public static void drawRoundedCorners(Bitmap src, Bitmap dest, int radius, int clearColor) { clearBitmap(dest, clearColor); Canvas canvas = new Canvas(dest); Rect sourceRect = WorkCache.RECT1.get(); Rect destRect = WorkCache.RECT2.get(); sourceRect.set(0, 0, src.getWidth(), src.getHeight()); destRect.set(0, 0, dest.getWidth(), dest.getHeight()); RectF roundRect = WorkCache.RECTF1.get(); roundRect.set(0, 0, dest.getWidth(), dest.getHeight()); Paint paint = WorkCache.PAINT.get(); paint.reset(); paint.setStyle(Paint.Style.FILL); paint.setColor(Color.RED); paint.setAntiAlias(true); canvas.drawRoundRect(roundRect, radius, radius, paint); paint.reset(); paint.setFilterBitmap(true); paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN)); canvas.drawBitmap(src, sourceRect, destRect, paint); canvas.setBitmap(null); }
/** * Drawing src bitmap to dest bitmap with round mask. Dest might be squared, src is recommended to * be square * * @param src source bitmap * @param dest destination bitmap * @param clearColor clear color */ public static void drawInRound(Bitmap src, Bitmap dest, int clearColor) { if (dest.getWidth() != dest.getHeight()) { throw new RuntimeException("dest Bitmap must have square size"); } clearBitmap(dest, clearColor); Canvas canvas = new Canvas(dest); int r = dest.getWidth() / 2; Rect sourceRect = WorkCache.RECT1.get(); Rect destRect = WorkCache.RECT2.get(); sourceRect.set(0, 0, src.getWidth(), src.getHeight()); destRect.set(0, 0, dest.getWidth(), dest.getHeight()); Paint paint = WorkCache.PAINT.get(); paint.reset(); paint.setStyle(Paint.Style.FILL); paint.setColor(Color.RED); paint.setAntiAlias(true); canvas.drawCircle(r, r, r, paint); paint.reset(); paint.setFilterBitmap(true); paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN)); canvas.drawBitmap(src, sourceRect, destRect, paint); canvas.setBitmap(null); }
private void drawPlaceHolder(Canvas canvas) { placeholderPaint.setColor(layout.placeHolderColor); placeholderTextPaint.setAlpha(255); placeholderPaint.setAlpha(255); avatarPaint.setAlpha(255); rect.set( layout.layoutAvatarLeft, layout.layoutAvatarTop, layout.layoutAvatarLeft + layout.layoutAvatarWidth, layout.layoutAvatarTop + layout.layoutAvatarWidth); canvas.drawRect(rect, placeholderPaint); if (layout.usePlaceholder) { canvas.drawText( layout.placeHolderName, layout.placeholderLeft, layout.placeholderTop, placeholderTextPaint); } else { rect2.set(0, 0, placeholder.getWidth(), placeholder.getHeight()); canvas.drawBitmap(placeholder, rect2, rect, avatarPaint); } }
@Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); // Draw the shadow canvas.drawOval(mShadowBounds, mShadowPaint); // TODO 0 Slices String label = ""; // if(mData.size() > 0) label = mData.get(mCurrentItem).mLabel; // else // label = NO_DATA_SLICE; // Draw the label text if (getShowText()) { canvas.drawText(label, mTextX, mTextY, mTextPaint); } // If the API level is less than 11, we can't rely on the view animation system to // do the scrolling animation. Need to tick it here and call postInvalidate() until the // scrolling is done. if (Build.VERSION.SDK_INT < 11) { tickScrollAnimation(); if (!mScroller.isFinished()) { postInvalidate(); } } }
private void drawFlippingHalf(Canvas canvas) { canvas.save(); mCamera.save(); final float degreesFlipped = getDegreesFlipped(); if (degreesFlipped > 90) { canvas.clipRect(isFlippingVertically() ? mTopRect : mLeftRect); if (mIsFlippingVertically) { mCamera.rotateX(degreesFlipped - 180); } else { mCamera.rotateY(180 - degreesFlipped); } } else { canvas.clipRect(isFlippingVertically() ? mBottomRect : mRightRect); if (mIsFlippingVertically) { mCamera.rotateX(degreesFlipped); } else { mCamera.rotateY(-degreesFlipped); } } mCamera.getMatrix(mMatrix); positionMatrix(); canvas.concat(mMatrix); setDrawWithLayer(mCurrentPage.v, true); drawChild(canvas, mCurrentPage.v, 0); drawFlippingShadeShine(canvas); mCamera.restore(); canvas.restore(); }
private void showCamera() { try { mPlayer = Manager.createPlayer("capture://video"); mPlayer.realize(); mVideoControl = (VideoControl) mPlayer.getControl("VideoControl"); Canvas canvas = new CameraCanvas(this, mVideoControl); canvas.addCommand(mBackCommand); canvas.addCommand(mCaptureCommand); canvas.setCommandListener(this); mDisplay.setCurrent(canvas); /* Form form = new Form("Camera form"); Item item = (Item)mVideoControl.initDisplayMode( GUIControl.USE_GUI_PRIMITIVE, null); form.append(item); form.addCommand(mBackCommand); form.addCommand(mCaptureCommand); form.setCommandListener(this); mDisplay.setCurrent(form); */ mPlayer.start(); } catch (IOException ioe) { handleException(ioe); } catch (MediaException me) { handleException(me); } }
public byte[] getTileImageData(int x, int y, int zoom) { mStream.reset(); Matrix matrix = new Matrix(mBaseMatrix); float scale = (float) (Math.pow(2, zoom) * mScale); matrix.postScale(scale, scale); matrix.postTranslate(-x * mDimension, -y * mDimension); mBitmap.eraseColor(Color.TRANSPARENT); Canvas c = new Canvas(mBitmap); c.setMatrix(matrix); // NOTE: Picture is not thread-safe. synchronized (mSvgPicture) { mSvgPicture.draw(c); } BufferedOutputStream stream = new BufferedOutputStream(mStream); mBitmap.compress(Bitmap.CompressFormat.PNG, 0, stream); try { stream.close(); } catch (IOException e) { Log.e(TAG, "Error while closing tile byte stream."); e.printStackTrace(); } return mStream.toByteArray(); }
// ============================================================================== public final int[] renderGlyph( char glyph, Paint paint, android.graphics.Matrix matrix, Rect bounds) { Path p = new Path(); paint.getTextPath(String.valueOf(glyph), 0, 1, 0.0f, 0.0f, p); RectF boundsF = new RectF(); p.computeBounds(boundsF, true); matrix.mapRect(boundsF); boundsF.roundOut(bounds); bounds.left--; bounds.right++; final int w = bounds.width(); final int h = bounds.height(); Bitmap bm = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888); Canvas c = new Canvas(bm); matrix.postTranslate(-bounds.left, -bounds.top); c.setMatrix(matrix); c.drawPath(p, paint); final int sizeNeeded = w * h; if (cachedRenderArray.length < sizeNeeded) cachedRenderArray = new int[sizeNeeded]; bm.getPixels(cachedRenderArray, 0, w, 0, 0, w, h); bm.recycle(); return cachedRenderArray; }
@Override protected void onDraw(Canvas canvas) { // draw the background and color wheel canvas.drawBitmap(mBackground, mBackgroundPosition.x, mBackgroundPosition.y, null); canvas.drawBitmap(mWheel, mWheelPosition.x, mWheelPosition.y, null); // setup paint for the gradient filling Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); paint.setStyle(Paint.Style.FILL); paint.setStrokeWidth(2.0f); // create a shader that will show the range of brightness settings float[] gradientStartColor = new float[3]; float[] gradientEndColor = new float[3]; System.arraycopy(mNewColor, 0, gradientStartColor, 0, mNewColor.length); System.arraycopy(mNewColor, 0, gradientEndColor, 0, mNewColor.length); gradientStartColor[2] = 1.0f; gradientEndColor[2] = 0.0f; Shader gradientShader = new LinearGradient( (float) (mWheelPosition.x + mRadius), mWheelPosition.y, mOuterArcRect.right, mWheelPosition.y + mWheel.getHeight(), Color.HSVToColor(gradientStartColor), Color.HSVToColor(gradientEndColor), Shader.TileMode.MIRROR); paint.setShader(gradientShader); canvas.drawPath(mArcPath, paint); drawHSCrosshairs(canvas); drawBrightnessIndicator(canvas); }
public void setFinal(boolean value) { if (is_final != value) { is_final = value; Canvas canvas = getAutomaton().getCanvas(); if (canvas != null) expose(canvas.getGraphics()); } }
/** * Reassigns the set of canvases that this explorer controls. Though the collection of canvas may * be empty, it may not be null. * * @param items * @requires items != null && for each element in item, element!= null && the Collection is backed * by a type that gives a consistent iteration order */ public void setDrawersCard(Collection<? extends Canvas> items) { canvases.clear(); buttonPane.removeAll(); int size = items.size(); if (size % 2 == 1) size++; size = buttonHeight * size; buttonPane.setPreferredSize(new Dimension(6, size)); int i = 0; for (Canvas item : items) { final int index = i; // final CButton button = new CButton(item.getColor(), // item.getColor().brighter().brighter().brighter(),item.getName()); CButton button = new CBorderlessButton(item.getName()); JComponent scroll = new CHoverScrollPane( item.getJComponent(), ScrollPolicy.VERTICAL_BAR_AS_NEEDED, ScrollPolicy.HORIZONTAL_BAR_AS_NEEDED, 18, item.getColor(), Color.darkGray); canvases.add(scroll); button.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { selectCanvas(index); } }); buttonPane.add(button); i++; } if (!canvases.isEmpty()) canvasPane.add(canvases.get(0)); this.revalidate(); }
@Override public void onDraw(Canvas canvas) { loadBitmap(); if (image != null) { shader = new BitmapShader( Bitmap.createScaledBitmap(image, canvas.getWidth(), canvas.getHeight(), false), Shader.TileMode.CLAMP, Shader.TileMode.CLAMP); paint.setShader(shader); int circleCenter = viewWidth / 2; canvas.drawCircle( circleCenter + borderWidth, circleCenter + borderWidth, circleCenter + borderWidth - 4.0f, paintBorder); if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) { canvas.drawCircle( circleCenter + borderWidth, circleCenter + borderWidth, circleCenter - 2.0f, paint); } else { canvas.drawCircle( circleCenter + borderWidth, circleCenter + borderWidth, circleCenter - 4.0f, paint); } // canvas.drawCircle(circleCenter + borderWidth, circleCenter + borderWidth, circleCenter - // 4.0f, paint); } }
public void draw(Canvas canvas) { int i = 1; copyBounds(mTmpRect); canvas.save(); float f; float f1; float f2; boolean flag; int j; if (ViewCompat.getLayoutDirection(mActivity.getWindow().getDecorView()) == 1) { flag = true; } else { flag = false; } if (flag) { i = -1; } j = mTmpRect.width(); f = -mOffset; f1 = j; f2 = mPosition; canvas.translate((float) i * (f * f1 * f2), 0.0F); if (flag && !mHasMirroring) { canvas.translate(j, 0.0F); canvas.scale(-1F, 1.0F); } super.draw(canvas); canvas.restore(); }
@Override protected void onDraw(Canvas canvas) { float r = CENTER_X - mPaint.getStrokeWidth() * 0.5f; canvas.translate(CENTER_X, CENTER_X); canvas.drawOval(new RectF(-r, -r, r, r), mPaint); canvas.drawCircle(0, 0, CENTER_RADIUS, mCenterPaint); if (mTrackingCenter) { int c = mCenterPaint.getColor(); mCenterPaint.setStyle(Paint.Style.STROKE); /* if (mHighlightCenter) { mCenterPaint.setAlpha(0xFF); } else { mCenterPaint.setAlpha(0x80); } */ canvas.drawCircle(0, 0, CENTER_RADIUS + mCenterPaint.getStrokeWidth(), mCenterPaint); mCenterPaint.setStyle(Paint.Style.FILL); mCenterPaint.setColor(c); } }
/** * This will generate a bitmap with the pattern as big as the rectangle we were allow to draw on. * We do this to chache the bitmap so we don't need to recreate it each time draw() is called * since it takes a few milliseconds. */ private void generatePatternBitmap() { if (getBounds().width() <= 0 || getBounds().height() <= 0) { return; } mBitmap = Bitmap.createBitmap(getBounds().width(), getBounds().height(), Config.ARGB_8888); Canvas canvas = new Canvas(mBitmap); Rect r = new Rect(); boolean verticalStartWhite = true; for (int i = 0; i <= numRectanglesVertical; i++) { boolean isWhite = verticalStartWhite; for (int j = 0; j <= numRectanglesHorizontal; j++) { r.top = i * mRectangleSize; r.left = j * mRectangleSize; r.bottom = r.top + mRectangleSize; r.right = r.left + mRectangleSize; canvas.drawRect(r, isWhite ? mPaintWhite : mPaintGray); isWhite = !isWhite; } verticalStartWhite = !verticalStartWhite; } }
public static void main(String[] args) { List<Shape> drawingList = new ArrayList<Shape>(); drawingList.add(new Circle()); drawingList.add(new Rectangle()); Canvas c = new Canvas(); c.drawAll(drawingList); }
public void onDraw(Canvas canvas) { // 검정색 배경으로 지운다. 빈 화면이면 지우기만 하고 리턴 canvas.drawColor(Color.BLACK); if (status == BLANK) { return; } // 도형 목록을 순회하면서 도형 정보대로 출력한다. int idx; for (idx = 0; idx < arShape.size(); idx++) { Paint Pnt = new Paint(); Pnt.setAntiAlias(true); Pnt.setColor(arShape.get(idx).color); Rect rt = arShape.get(idx).rt; switch (arShape.get(idx).what) { case Shape.RECT: canvas.drawRect(rt, Pnt); break; case Shape.CIRCLE: canvas.drawCircle( rt.left + rt.width() / 2, rt.top + rt.height() / 2, rt.width() / 2, Pnt); break; case Shape.TRIANGLE: Path path = new Path(); path.moveTo(rt.left + rt.width() / 2, rt.top); path.lineTo(rt.left, rt.bottom); path.lineTo(rt.right, rt.bottom); canvas.drawPath(path, Pnt); break; } } }
@Override public Surface drawLine(float x0, float y0, float x1, float y1, float width) { canvas.save(); canvas.setStrokeWidth(width); canvas.drawLine(x0, y0, x1, y1); canvas.restore(); return this; }
private static Bitmap convertToAlphaMask(Bitmap b) { Bitmap a = Bitmap.createBitmap(b.getWidth(), b.getHeight(), Bitmap.Config.ALPHA_8); Canvas c = new Canvas(a); Paint pt = new Paint(); pt.setColorFilter(new ColorMatrixColorFilter(MASK)); c.drawBitmap(b, 0.0f, 0.0f, pt); return a; }
public static void DrawString(Surface g, TextLayout layout, int x, int y) { CanvasImage c = Global.m_graphics.createImage( (int) Math.ceil(layout.width()), (int) Math.ceil(layout.height())); Canvas gc = c.canvas(); gc.drawText(layout, 0, 0); g.drawImage(c, x, y); }
private void pushTransform(Attributes atts) { final String transform = getStringAttr("transform", atts); canvas.save(); if (transform != null) { final Matrix matrix = parseTransform(transform); canvas.concat(matrix); } }
public void setInitial(boolean value) { if (is_initial != value) { is_initial = value; getAutomaton().invalidateBounds(); Canvas canvas = getAutomaton().getCanvas(); if (canvas != null) expose(canvas.getGraphics()); } }
@Override protected void onDraw(Canvas canvas) { canvas.drawColor(Color.LTGRAY); canvas.drawBitmap(mBitmap, 0, 0, mBitmapPaint); canvas.drawPath(mPath, mPaint); }
/** * Draws the game controls. * * @param Canvas canvas */ private void drawControls(Canvas canvas) { canvas.drawBitmap(mCtrlUpArrow.getBitmap(), mCtrlUpArrow.getX(), mCtrlUpArrow.getY(), null); canvas.drawBitmap( mCtrlDownArrow.getBitmap(), mCtrlDownArrow.getX(), mCtrlDownArrow.getY(), null); canvas.drawBitmap( mCtrlLeftArrow.getBitmap(), mCtrlLeftArrow.getX(), mCtrlLeftArrow.getY(), null); canvas.drawBitmap( mCtrlRightArrow.getBitmap(), mCtrlRightArrow.getX(), mCtrlRightArrow.getY(), null); }
void myDraw() { float width, height; width = getMeasuredWidth(); height = getMeasuredHeight(); canvas = holder.lockCanvas(); canvas.drawColor(Color.GREEN); canvas.drawPath(path, paint); holder.unlockCanvasAndPost(canvas); }
@Override public void draw(Canvas canvas) { Rect bounds = getBounds(); paint.setColor(COLOR_LIGHT); int width = bounds.width() - STROKE_WIDTH; int height = bounds.height() - STROKE_WIDTH; canvas.drawPath(createLightPath(width, height), paint); paint.setColor(COLOR_DARK); canvas.drawPath(createDarkPath(width, height), paint); }
static void drawSomething(Canvas canvas) { Paint p = new Paint(Paint.ANTI_ALIAS_FLAG); p.setColor(0x88FF0000); canvas.drawCircle(50, 50, 40, p); p.setColor(Color.GREEN); p.setTextSize(30); canvas.drawText("Pictures", 60, 60, p); }
public void onDraw(Canvas canvas) { canvas.drawColor(Color.LTGRAY); Paint Pnt = new Paint(); String str = "Custom Font Test"; Pnt.setAntiAlias(true); Pnt.setTypeface(mFont); Pnt.setTextSize(30); canvas.drawText(str, 10, 40, Pnt); }
@Override protected void dispatchDraw(Canvas canvas) { if (showcaseX < 0 || showcaseY < 0 || isRedundant) { super.dispatchDraw(canvas); return; } // Draw the semi-transparent background canvas.drawColor(backColor); // Draw to the scale specified Matrix mm = new Matrix(); mm.postScale(scaleMultiplier, scaleMultiplier, showcaseX, showcaseY); canvas.setMatrix(mm); // Erase the area for the ring canvas.drawCircle(showcaseX, showcaseY, showcaseRadius, mEraser); boolean recalculateText = makeVoidedRect() || mAlteredText; mAlteredText = false; showcase.setBounds(voidedArea); showcase.draw(canvas); canvas.setMatrix(new Matrix()); if (!TextUtils.isEmpty(mTitleText) || !TextUtils.isEmpty(mSubText)) { if (recalculateText) mBestTextPosition = getBestTextPosition(canvas.getWidth(), canvas.getHeight()); if (!TextUtils.isEmpty(mTitleText)) { // TODO: use a dynamic detail layout canvas.drawText(mTitleText, mBestTextPosition[0], mBestTextPosition[1], mPaintTitle); } if (!TextUtils.isEmpty(mSubText)) { canvas.save(); if (recalculateText) mDynamicDetailLayout = new DynamicLayout( mSubText, mPaintDetail, ((Number) mBestTextPosition[2]).intValue(), Layout.Alignment.ALIGN_NORMAL, 1.2f, 1.0f, true); canvas.translate(mBestTextPosition[0], mBestTextPosition[1] + 12 * metricScale); mDynamicDetailLayout.draw(canvas); canvas.restore(); } } super.dispatchDraw(canvas); }