@Override
public void onChildDrawOver(
Canvas c,
RecyclerView recyclerView,
RecyclerView.ViewHolder viewHolder,
float dX,
float dY,
int actionState,
boolean isCurrentlyActive) {
super.onChildDrawOver(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive);
if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
View itemView = viewHolder.itemView;
c.save();
if (dX > 0) {
c.clipRect(
itemView.getLeft(), itemView.getTop(), itemView.getLeft() + dX, itemView.getBottom());
c.translate(itemView.getLeft(), itemView.getTop());
} else {
c.clipRect(
itemView.getRight() + dX, itemView.getTop(), itemView.getRight(), itemView.getBottom());
c.translate(itemView.getRight() + dX, itemView.getTop());
}
mAdapter.onItemSwiping(c, viewHolder, dX, dY, isCurrentlyActive);
c.restore();
}
}
@Override
protected void onDraw(Canvas canvas) {
if (user == null && chat == null && encryptedChat == null) {
return;
}
if (cellLayout == null) {
requestLayout();
return;
}
if (useSeparator) {
int h = getMeasuredHeight();
if (!usePadding) {
canvas.drawLine(0, h - 1, getMeasuredWidth(), h - 1, linePaint);
} else {
canvas.drawLine(
AndroidUtilities.dp(11),
h - 1,
getMeasuredWidth() - AndroidUtilities.dp(11),
h - 1,
linePaint);
}
}
if (drawAlpha != 1) {
canvas.saveLayerAlpha(
0,
0,
canvas.getWidth(),
canvas.getHeight(),
(int) (255 * drawAlpha),
Canvas.HAS_ALPHA_LAYER_SAVE_FLAG);
}
if (cellLayout.drawNameLock) {
setDrawableBounds(lockDrawable, cellLayout.nameLockLeft, cellLayout.nameLockTop);
lockDrawable.draw(canvas);
} else if (cellLayout.drawNameGroup) {
setDrawableBounds(groupDrawable, cellLayout.nameLockLeft, cellLayout.nameLockTop);
groupDrawable.draw(canvas);
} else if (cellLayout.drawNameBroadcast) {
setDrawableBounds(broadcastDrawable, cellLayout.nameLockLeft, cellLayout.nameLockTop);
broadcastDrawable.draw(canvas);
}
canvas.save();
canvas.translate(cellLayout.nameLeft, cellLayout.nameTop);
cellLayout.nameLayout.draw(canvas);
canvas.restore();
if (cellLayout.onlineLayout != null) {
canvas.save();
canvas.translate(cellLayout.onlineLeft, cellLayout.onlineTop);
cellLayout.onlineLayout.draw(canvas);
canvas.restore();
}
avatarImage.draw(canvas);
}
private void drawOverMap(Canvas canvas, RotatedTileBox tileBox, DrawSettings drawSettings) {
final QuadPoint c = tileBox.getCenterPixelPoint();
synchronized (this) {
if (bufferBitmap != null && !bufferBitmap.isRecycled()) {
canvas.save();
canvas.rotate(tileBox.getRotate(), c.x, c.y);
drawBasemap(canvas);
canvas.restore();
}
}
for (int i = 0; i < layers.size(); i++) {
try {
OsmandMapLayer layer = layers.get(i);
canvas.save();
// rotate if needed
if (!layer.drawInScreenPixels()) {
canvas.rotate(tileBox.getRotate(), c.x, c.y);
}
layer.onDraw(canvas, tileBox, drawSettings);
canvas.restore();
} catch (IndexOutOfBoundsException e) {
// skip it
}
}
if (showMapPosition) {
canvas.drawCircle(c.x, c.y, 3 * dm.density, paintCenter);
canvas.drawCircle(c.x, c.y, 7 * dm.density, paintCenter);
}
}
/**
* Draws value and label layout.
*
* @param canvas the canvas for drawing
*/
private void drawValue(Canvas canvas) {
valuePaint.setColor(valueTextColor);
valuePaint.drawableState = getDrawableState();
labelPaint.setColor(labelTextColor);
labelPaint.drawableState = getDrawableState();
Rect bounds = new Rect();
itemsLayout.getLineBounds(visibleItems / 2, bounds);
// draw label
if (labelLayout != null) {
canvas.save();
canvas.translate(itemsLayout.getWidth() + LABEL_OFFSET, bounds.top);
labelLayout.draw(canvas);
canvas.restore();
}
// draw current value
if (valueLayout != null) {
canvas.save();
canvas.translate(0, bounds.top + scrollingOffset);
valueLayout.draw(canvas);
canvas.restore();
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (currentMessageObject == null) {
return;
}
if (currentMessageObject.isOutOwner()) {
timePaint.setColor(theme.ChatMusicCell_timePaint_color);
} else {
timePaint.setColor(theme.ChatMusicCell_timePaint_color_2);
}
radialProgress.draw(canvas);
canvas.save();
canvas.translate(timeX + titleX, AndroidUtilities.dp(12) + namesOffset);
titleLayout.draw(canvas);
canvas.restore();
canvas.save();
if (MediaController.getInstance().isPlayingAudio(currentMessageObject)) {
canvas.translate(seekBarX, seekBarY);
seekBar.draw(canvas);
} else {
canvas.translate(timeX + authorX, AndroidUtilities.dp(32) + namesOffset);
authorLayout.draw(canvas);
}
canvas.restore();
canvas.save();
canvas.translate(timeX, AndroidUtilities.dp(52) + namesOffset);
timeLayout.draw(canvas);
canvas.restore();
}
public void draw(Canvas canvas) {
ArrayList<Point> points = mPointCloud;
canvas.save(Canvas.MATRIX_SAVE_FLAG);
canvas.scale(mScale, mScale, mCenterX, mCenterY);
for (int i = 0; i < points.size(); i++) {
Point point = points.get(i);
final float pointSize = interp(MAX_POINT_SIZE, MIN_POINT_SIZE, point.radius / mOuterRadius);
final float px = point.x + mCenterX;
final float py = point.y + mCenterY;
int alpha = getAlphaForPoint(point);
if (alpha == 0) continue;
if (mDrawable != null) {
canvas.save(Canvas.MATRIX_SAVE_FLAG);
final float cx = mDrawable.getIntrinsicWidth() * 0.5f;
final float cy = mDrawable.getIntrinsicHeight() * 0.5f;
final float s = pointSize / MAX_POINT_SIZE;
canvas.scale(s, s, px, py);
canvas.translate(px - cx, py - cy);
mDrawable.setAlpha(alpha);
mDrawable.draw(canvas);
canvas.restore();
} else {
mPaint.setAlpha(alpha);
canvas.drawCircle(px, py, pointSize, mPaint);
}
}
canvas.restore();
}
@Override
public void onDraw(Canvas canvas) {
super.onDraw(canvas);
int count = mPagesCount;
if (count == 0) {
return;
}
float cx = canvas.getWidth() >> 1;
float cy = canvas.getHeight() >> 1;
int totalCount = 2 * count - 1;
int halfCount = totalCount / 2;
float itemWithOffset = mIndicatorElementSize + mIndicatorElementSpacing;
float halfItemWithOffset = mIndicatorElementSize / 2 + mIndicatorElementSpacing;
float halfSize = mIndicatorElementSize / 2f;
float halfSpacing = mIndicatorElementSpacing / 2f;
float startX = cx - halfCount * (mIndicatorElementSize + mIndicatorElementSpacing);
float top = cy - halfSize;
float bottom = cy + halfSize;
// if we have odd elements - need to set indicators in center
if (totalCount % 2 != 0) {
startX -= halfSize + halfSpacing;
}
int i;
for (i = 0; i < totalCount; i++) {
// skip empty spaces
if (i % 2 != 0) {
continue;
}
float left = startX + (mIndicatorElementSize + mIndicatorElementSpacing) * i;
float right = left + mIndicatorElementSize;
mElementBounds.set(left, top, right, bottom);
mRenderer.draw(canvas, mElementBounds, mIndicatorPaint, false);
}
// multiply on 2 because there are spaces between elements
float activeItemOffset = (mSelectedPosition + mScrolledOffset) * 2;
float left = startX + (mIndicatorElementSize + mIndicatorElementSpacing) * activeItemOffset;
float right = left + mIndicatorElementSize;
mElementBounds.set(left, top, right, bottom);
canvas.clipRect(mClipBounds);
canvas.save();
canvas.rotate(ANGLE_360 * mScrolledOffset, mElementBounds.centerX(), mElementBounds.centerY());
mRenderer.draw(canvas, mElementBounds, mIndicatorSelectedPaint, true);
canvas.restore();
if (mIsInfiniteScroll && mSelectedPosition == mPagesCount - 1) { // isInfinite && isEnd
activeItemOffset = (1f - mScrolledOffset) * 2;
left = mClipBounds.left - itemWithOffset * activeItemOffset + halfItemWithOffset;
right = left + mIndicatorElementSize;
mElementBounds.set(left, top, right, bottom);
canvas.save();
canvas.rotate(
ANGLE_360 * mScrolledOffset, mElementBounds.centerX(), mElementBounds.centerY());
mRenderer.draw(canvas, mElementBounds, mIndicatorSelectedPaint, true);
canvas.restore();
}
}
/** 绘制焦点框 */
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (Style.RECTANGLE == mStyle) {
mFocusPath.addRect(mFocusRect, Path.Direction.CCW);
canvas.save();
canvas.clipRect(0, 0, getWidth(), getHeight());
canvas.clipPath(mFocusPath, Region.Op.DIFFERENCE);
canvas.drawColor(mMaskColor);
canvas.restore();
} else if (Style.CIRCLE == mStyle) {
float radius =
Math.min(
(mFocusRect.right - mFocusRect.left) / 2, (mFocusRect.bottom - mFocusRect.top) / 2);
mFocusPath.addCircle(mFocusMidPoint.x, mFocusMidPoint.y, radius, Path.Direction.CCW);
canvas.save();
canvas.clipRect(0, 0, getWidth(), getHeight());
canvas.clipPath(mFocusPath, Region.Op.DIFFERENCE);
canvas.drawColor(mMaskColor);
canvas.restore();
}
mBorderPaint.setColor(mBorderColor);
mBorderPaint.setStyle(Paint.Style.STROKE);
mBorderPaint.setStrokeWidth(mBorderWidth);
mBorderPaint.setAntiAlias(true);
canvas.drawPath(mFocusPath, mBorderPaint);
mFocusPath.reset();
}
private void drawRightTopArc(Canvas canvas) {
canvas.save();
canvas.translate(0, -radius * 3); // the center of the circle in the rightTop
canvas.drawArc(oval, -22.5f, -135, true, arcPaint);
arcPaint.setStyle(Paint.Style.STROKE);
arcPaint.setColor(Color.WHITE);
canvas.drawArc(
oval, -22.5f, -135, false,
arcPaint); // @param useCenter: useCenter If true, include the center of the oval in the
// arc, and close it if it is being stroked. This will draw a wedge
// ======== draw arc text ==========
canvas.save();
canvas.rotate(-135 / 2); // 到正中间
for (int i = 0; i < 135; i += 33.75) { // 33.75 * 4 = 135;
canvas.save();
canvas.rotate(i);
canvas.drawText("Item", 0, -width * 5 / 32, textPaint);
canvas.restore();
}
canvas.restore();
// ======== draw arc text ==========
canvas.restore();
}
protected void onDraw(Canvas canvas) {
mCalendar = Calendar.getInstance();
super.onDraw(canvas);
int minute = mCalendar.get(Calendar.MINUTE); // 得到当前分钟数
int hour = mCalendar.get(Calendar.HOUR); // 得到当前小时数
int sec = mCalendar.get(Calendar.SECOND); // 得到当前秒数
float minuteDegree = minute / 60f * 360; // 得到分针旋转的角度
canvas.save();
canvas.rotate(minuteDegree, width / 2, height / 2);
canvas.drawLine(width / 2, height / 2 - 250, width / 2, height / 2 + 40, mPaintMinute);
canvas.restore();
float hourDegree = (hour * 60 + minute) / 12f / 60 * 360; // 得到时钟旋转的角度
canvas.save();
canvas.rotate(hourDegree, width / 2, height / 2);
canvas.drawLine(width / 2, height / 2 - 200, width / 2, height / 2 + 30, mPaintHour);
canvas.restore();
float secDegree = sec / 60f * 360; // 得到秒针旋转的角度
canvas.save();
canvas.rotate(secDegree, width / 2, height / 2);
canvas.drawLine(width / 2, height / 2 - 300, width / 2, height / 2 + 40, mPaintSec);
canvas.restore();
}
@Override
public void dispatchDraw(Canvas canvas) {
canvas.save();
if (divider != null) {
divider.setBounds(0, 0, dividerWidth, dividerHeight);
}
final int len = views.size();
for (int i = 0; i < len; i++) {
View v = views.get(i);
canvas.save();
canvas.clipRect(0, 0, getWidth(), v.getMeasuredHeight());
v.draw(canvas);
canvas.restore();
if (divider != null) {
divider.draw(canvas);
canvas.translate(0, dividerHeight);
}
canvas.translate(0, v.getMeasuredHeight());
}
canvas.restore();
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.drawARGB(255, 255, 255, 255);
canvas.save();
canvas.translate(120.0f, 50.0f);
canvas.drawBitmap(mBitmap1, 0.0f, 0.0f, mColorMatrixPaint);
canvas.translate(0.0f, 50.0f + mBitmap1.getHeight());
canvas.drawBitmap(mBitmap1, 0.0f, 0.0f, mLightingPaint);
canvas.translate(0.0f, 50.0f + mBitmap1.getHeight());
canvas.drawBitmap(mBitmap1, 0.0f, 0.0f, mBlendPaint);
canvas.restore();
canvas.save();
canvas.translate(120.0f + mBitmap1.getWidth() + 120.0f, 50.0f);
canvas.drawBitmap(mBitmap2, 0.0f, 0.0f, mColorMatrixPaint);
canvas.translate(0.0f, 50.0f + mBitmap2.getHeight());
canvas.drawBitmap(mBitmap2, 0.0f, 0.0f, mLightingPaint);
canvas.translate(0.0f, 50.0f + mBitmap2.getHeight());
canvas.drawBitmap(mBitmap2, 0.0f, 0.0f, mBlendPaint);
canvas.restore();
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
measureRect();
if (mDragHandlerPaint == null) {
return;
}
if (mMarginPaint == null) {
return;
}
if (INNER_RECT) {
canvas.save();
canvas.drawLine(
mBitmapRectPoints[0],
mBitmapRectPoints[1],
mBitmapRectPoints[2],
mBitmapRectPoints[3],
mMarginPaint);
canvas.drawLine(
mBitmapRectPoints[4],
mBitmapRectPoints[5],
mBitmapRectPoints[6],
mBitmapRectPoints[7],
mMarginPaint);
canvas.drawLine(
mBitmapRectPoints[0],
mBitmapRectPoints[1],
mBitmapRectPoints[4],
mBitmapRectPoints[5],
mMarginPaint);
canvas.drawLine(
mBitmapRectPoints[2],
mBitmapRectPoints[3],
mBitmapRectPoints[6],
mBitmapRectPoints[7],
mMarginPaint);
canvas.drawCircle(mBitmapRectPoints[0], mBitmapRectPoints[1], mRadius, mDragHandlerPaint);
canvas.drawCircle(mBitmapRectPoints[2], mBitmapRectPoints[3], mRadius, mDragHandlerPaint);
canvas.drawCircle(mBitmapRectPoints[4], mBitmapRectPoints[5], mRadius, mDragHandlerPaint);
canvas.drawCircle(mBitmapRectPoints[6], mBitmapRectPoints[7], mRadius, mDragHandlerPaint);
canvas.restore();
} else {
canvas.save();
canvas.drawRect(mMarginRectF, mMarginPaint);
canvas.drawCircle(mMarginRectF.left, mMarginRectF.top, mRadius, mDragHandlerPaint);
canvas.drawCircle(mMarginRectF.right, mMarginRectF.top, mRadius, mDragHandlerPaint);
canvas.drawCircle(mMarginRectF.left, mMarginRectF.bottom, mRadius, mDragHandlerPaint);
canvas.drawCircle(mMarginRectF.right, mMarginRectF.bottom, mRadius, mDragHandlerPaint);
canvas.restore();
}
if (!(mDragPoint.x == INVALID_POINT && mDragPoint.y == INVALID_POINT)) {
canvas.save();
canvas.drawCircle(mMarginRectF.centerX(), mMarginRectF.centerY(), mRadius, mDragHandlerPaint);
canvas.restore();
}
}
@Override
public void draw(Canvas canvas, Matrix matrix, float currentZoom, float currentRotateDegrees) {
canvas.save();
if (this.isVisible && this.currentPosition != null) {
float goal[] = {currentPosition.x, currentPosition.y};
matrix.mapPoints(goal);
canvas.drawCircle(goal[0], goal[1], defaultLocationCircleRadius, locationPaint);
if (currentMode == MODE_COMPASS) {
/*
for (int i = 0; i < 360 / COMPASS_DELTA_ANGLE; i++)
{
canvas.save();
canvas.rotate(COMPASS_DELTA_ANGLE * i, goal[0], goal[1]);
if (i % (90 / COMPASS_DELTA_ANGLE) == 0)
{
canvas.drawLine(goal[0], goal[1] - compassRadius + compassLocationCircleRadius, goal[0], goal[1] - compassRadius + compassLocationCircleRadius - compassLineLength, compassLinePaint);
}
else
{
canvas.drawCircle(goal[0], goal[1] - compassRadius, compassLocationCircleRadius, new Paint());
}
canvas.restore();
}*/
if (compassIndicatorArrowBitmap != null) {
canvas.save();
canvas.rotate(this.compassIndicatorArrowRotateDegree, goal[0], goal[1]);
canvas.drawBitmap(
compassIndicatorArrowBitmap,
goal[0] - compassIndicatorArrowBitmap.getWidth() / 2,
goal[1] - defaultLocationCircleRadius - compassIndicatorGap,
new Paint());
canvas.restore();
/*
if (360 - (this.compassIndicatorArrowRotateDegree - this.compassIndicatorCircleRotateDegree) > 180)
{
canvas.drawArc(new RectF(goal[0] - compassRadius, goal[1] - compassRadius, goal[0] + compassRadius, goal[1] + compassRadius), -90 + this.compassIndicatorCircleRotateDegree, (this.compassIndicatorArrowRotateDegree - this.compassIndicatorCircleRotateDegree), false,
indicatorArcPaint);
}
else
{
canvas.drawArc(new RectF(goal[0] - compassRadius, goal[1] - compassRadius, goal[0] + compassRadius, goal[1] + compassRadius), -90 + this.compassIndicatorArrowRotateDegree, 360 - (this.compassIndicatorArrowRotateDegree - this.compassIndicatorCircleRotateDegree), false,
indicatorArcPaint);
}*/
}
canvas.save();
canvas.rotate(compassIndicatorCircleRotateDegree, goal[0], goal[1]);
// canvas.drawCircle(goal[0], goal[1] - compassRadius, compassIndicatorCircleRadius,
// indicatorCirclePaint);
canvas.restore();
}
}
canvas.restore();
}
@Override
protected void onDraw(Canvas canvas) {
canvas.save();
if (highlight) highlight(canvas);
canvas.restore();
zeichenInfos(canvas);
canvas.restore();
zeichenGatter(canvas);
super.onDraw(canvas);
}
@Override
public void draw(Canvas canvas) {
if (mDrawables.size() == 1) {
mDrawables.get(0).draw(canvas);
return;
}
int width = getBounds().width();
int height = getBounds().height();
canvas.save();
canvas.clipRect(0, 0, width, height);
if (mDrawables.size() == 2 || mDrawables.size() == 3) {
// Paint left half
canvas.save();
canvas.clipRect(0, 0, width / 2, height);
canvas.translate(-width / 4, 0);
mDrawables.get(0).draw(canvas);
canvas.restore();
}
if (mDrawables.size() == 2) {
// Paint right half
canvas.save();
canvas.clipRect(width / 2, 0, width, height);
canvas.translate(width / 4, 0);
mDrawables.get(1).draw(canvas);
canvas.restore();
} else {
// Paint top right
canvas.save();
canvas.scale(.5f, .5f);
canvas.translate(width, 0);
mDrawables.get(1).draw(canvas);
// Paint bottom right
canvas.translate(0, height);
mDrawables.get(2).draw(canvas);
canvas.restore();
}
if (mDrawables.size() >= 4) {
// Paint top left
canvas.save();
canvas.scale(.5f, .5f);
mDrawables.get(0).draw(canvas);
// Paint bottom left
canvas.translate(0, height);
mDrawables.get(3).draw(canvas);
canvas.restore();
}
canvas.restore();
}
@Override
public void draw(Canvas canvas) {
// Draw the bounding boxes
drawBoundingBoxes(canvas);
// Set the right values for the paint
operatorPaint.setColor(getColor());
operatorPaint.setTextSize(findTextSize());
// Get our operator bounding boxes
Rect[] operatorBounding = this.getOperatorBoundingBoxes();
// Draws the operator
canvas.save();
Rect textBounding = new Rect();
operatorPaint.getTextBounds(type.getName(), 0, type.getName().length(), textBounding);
canvas.translate(
(operatorBounding[0].width() - textBounding.width()) / 2,
(operatorBounding[0].height() - textBounding.height()) / 2);
canvas.drawText(
type.getName(),
operatorBounding[0].left - textBounding.left,
operatorBounding[0].top - textBounding.top,
operatorPaint);
canvas.restore();
// Use stroke style for the parentheses
operatorPaint.setStyle(Paint.Style.STROKE);
// Draw the left bracket
canvas.save();
canvas.clipRect(operatorBounding[1], Region.Op.INTERSECT);
RectF bracket = new RectF(operatorBounding[1]);
bracket.inset(0, -operatorPaint.getStrokeWidth());
bracket.offset(bracket.width() / 4, 0);
canvas.drawArc(bracket, 100.0f, 160.0f, false, operatorPaint);
canvas.restore();
// Draw the right bracket
canvas.save();
canvas.clipRect(operatorBounding[2], Region.Op.INTERSECT);
bracket = new RectF(operatorBounding[2]);
bracket.inset(0, -operatorPaint.getStrokeWidth());
bracket.offset(-bracket.width() / 4, 0);
canvas.drawArc(bracket, -80.0f, 160.0f, false, operatorPaint);
canvas.restore();
// Set the paint back to fill style
operatorPaint.setStyle(Paint.Style.FILL);
// Draw the children
drawChildren(canvas);
}
@Override
protected void drawItems(Canvas canvas) {
canvas.save();
int w = getMeasuredWidth();
int h = getMeasuredHeight();
int iw = getItemDimension();
// resetting intermediate bitmap and recreating canvases
mSpinBitmap.eraseColor(0);
Canvas c = new Canvas(mSpinBitmap);
Canvas cSpin = new Canvas(mSpinBitmap);
int left = (mCurrentItemIdx - mFirstItemIdx) * iw + (iw - getWidth()) / 2;
c.translate(-left + mScrollingOffset, mItemsPadding);
mItemsLayout.draw(c);
mSeparatorsBitmap.eraseColor(0);
Canvas cSeparators = new Canvas(mSeparatorsBitmap);
if (mSelectionDivider != null) {
// draw the top divider
int leftOfLeftDivider = (getWidth() - iw - mSelectionDividerWidth) / 2;
int rightOfLeftDivider = leftOfLeftDivider + mSelectionDividerWidth;
cSeparators.save();
// On Gingerbread setBounds() is ignored resulting in an ugly visual bug.
cSeparators.clipRect(leftOfLeftDivider, 0, rightOfLeftDivider, h);
mSelectionDivider.setBounds(leftOfLeftDivider, 0, rightOfLeftDivider, h);
mSelectionDivider.draw(cSeparators);
cSeparators.restore();
cSeparators.save();
// draw the bottom divider
int leftOfRightDivider = leftOfLeftDivider + iw;
int rightOfRightDivider = rightOfLeftDivider + iw;
// On Gingerbread setBounds() is ignored resulting in an ugly visual bug.
cSeparators.clipRect(leftOfRightDivider, 0, rightOfRightDivider, h);
mSelectionDivider.setBounds(leftOfRightDivider, 0, rightOfRightDivider, h);
mSelectionDivider.draw(cSeparators);
cSeparators.restore();
}
cSpin.drawRect(0, 0, w, h, mSelectorWheelPaint);
cSeparators.drawRect(0, 0, w, h, mSeparatorsPaint);
canvas.drawBitmap(mSpinBitmap, 0, 0, null);
canvas.drawBitmap(mSeparatorsBitmap, 0, 0, null);
canvas.restore();
}
/*
* (non-Javadoc)
*
* @see android.view.View#onDraw(android.graphics.Canvas)
*/
@Override
protected void onDraw(final Canvas canvas) {
// All of our positions are using our internal coordinate system.
// Instead of translating
// them we let Canvas do the work for us.
canvas.translate(mTranslationOffsetX, mTranslationOffsetY);
final float progressRotation = getCurrentRotation();
// draw the background
if (!mOverrdraw) {
canvas.drawArc(mCircleBounds, 270, -(360 - progressRotation), false, mBackgroundColorPaint);
}
// draw the progress or a full circle if overdraw is true
canvas.drawArc(
mCircleBounds, 270, mOverrdraw ? 360 : progressRotation, false, mProgressColorPaint);
// draw the marker at the correct rotated position
if (mIsMarkerEnabled) {
final float markerRotation = getMarkerRotation();
canvas.save();
canvas.rotate(markerRotation - 90);
canvas.drawLine(
(float) (mThumbPosX + mThumbRadius / 2 * 1.4),
mThumbPosY,
(float) (mThumbPosX - mThumbRadius / 2 * 1.4),
mThumbPosY,
mMarkerColorPaint);
canvas.restore();
}
if (isThumbEnabled()) {
// draw the thumb square at the correct rotated position
canvas.save();
canvas.rotate(progressRotation - 90);
// rotate the square by 45 degrees
canvas.rotate(45, mThumbPosX, mThumbPosY);
mSquareRect.left = mThumbPosX - mThumbRadius / 3;
mSquareRect.right = mThumbPosX + mThumbRadius / 3;
mSquareRect.top = mThumbPosY - mThumbRadius / 3;
mSquareRect.bottom = mThumbPosY + mThumbRadius / 3;
canvas.drawRect(mSquareRect, mThumbColorPaint);
canvas.restore();
}
}
/** Called from the game loop to render every frame to the canvas */
@Override
public void updateCanvas(Canvas canvas) {
// clear the screen.
canvas.drawColor(Color.BLACK);
// simple state machine, draw screen depending on the current state.
switch (state) {
case GAME_INIT:
case GAME_LEVEL:
for (int i = 0; i < robot.length; i++) {
for (int j = 0; j < robot[j].length; j++) {
if (robot[i][j] != null) {
robot[i][j].draw(canvas, i * 24, j * 24);
}
}
}
font.print(canvas, 10, 150, "Test 123");
// particles.draw(canvas);
canvas.save();
ship.draw(canvas);
canvas.restore();
// draw hud
// drawHUD();
break;
case GAME_OVER:
// drawGameOver();
break;
case GAME_COMPLETE:
// drawGameComplete();
break;
}
}
@Override
public void draw(Canvas canvas, Paint paint) {
float circleSpacing = 12;
float x = getWidth() / 2;
float y = getHeight() / 2;
// draw fill circle
canvas.save();
canvas.translate(x, y);
canvas.scale(scaleFloat1, scaleFloat1);
paint.setStyle(Paint.Style.FILL);
canvas.drawCircle(0, 0, x / 2.5f, paint);
canvas.restore();
canvas.translate(x, y);
canvas.scale(scaleFloat2, scaleFloat2);
canvas.rotate(degrees);
paint.setStrokeWidth(3);
paint.setStyle(Paint.Style.STROKE);
// draw two arc
float[] startAngles = new float[] {225, 45};
for (int i = 0; i < 2; i++) {
RectF rectF =
new RectF(-x + circleSpacing, -y + circleSpacing, x - circleSpacing, y - circleSpacing);
canvas.drawArc(rectF, startAngles[i], 90, false, paint);
}
}
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (h != null && !h.isRecycled()) {
canvas.save();
s.reset();
s.postScale(d, d, q.x, q.y);
s.postTranslate(-i.left, -i.top);
canvas.drawBitmap(h, s, null);
canvas.restore();
canvas.save();
canvas.translate(-i.left, -i.top);
canvas.drawCircle(q.x, q.y, r, l);
canvas.restore();
}
canvas.drawRect(f, m);
}
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);
}
}
}
@Override
public void draw(Canvas canvas) {
final float scale = mDisplayScale;
boolean isRecycled = false;
if (scale != 1f) {
canvas.save();
canvas.scale(scale, scale);
try {
super.draw(canvas);
} catch (Exception ex) {
isRecycled = true;
}
canvas.restore();
} else {
try {
super.draw(canvas);
} catch (Exception ex) {
isRecycled = true;
}
}
Check.d(!isRecycled, mTraceContent);
}
@Override
protected void onDraw(Canvas canvas) {
if ((patternPressed == null) || (patternNoraml == null)) {
return;
}
// 绘制3*3的图标
for (int i = 0; i < numRow; i++) {
for (int j = 0; j < numColum; j++) {
paint.setColor(-16777216);
int i1 = j * patternHeight + j * this.g;
int i2 = i * patternWidth + i * this.f;
canvas.save();
canvas.translate(i1, i2);
String curNum = String.valueOf(numColum * i + j);
if (!TextUtils.isEmpty(lockPassStr)) {
if (lockPassStr.indexOf(curNum) == -1) {
// 未选中
patternNoraml.draw(canvas);
} else {
// 被选中
patternPressed.draw(canvas);
}
} else {
// 重置状态
patternNoraml.draw(canvas);
}
canvas.restore();
}
}
}
@Override
protected void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
if (mPinnedSection != null) {
// prepare variables
int pLeft = getListPaddingLeft();
int pTop = getListPaddingTop();
View view = mPinnedSection.view;
// draw child
canvas.save();
int clipHeight =
view.getHeight()
+ (mShadowDrawable == null ? 0 : Math.min(mShadowHeight, mSectionsDistanceY));
canvas.clipRect(pLeft, pTop, pLeft + view.getWidth(), pTop + clipHeight);
canvas.translate(pLeft, pTop + mTranslateY);
drawChild(canvas, mPinnedSection.view, getDrawingTime());
if (mShadowDrawable != null && mSectionsDistanceY > 0) {
mShadowDrawable.setBounds(
mPinnedSection.view.getLeft(),
mPinnedSection.view.getBottom(),
mPinnedSection.view.getRight(),
mPinnedSection.view.getBottom() + mShadowHeight);
mShadowDrawable.draw(canvas);
}
canvas.restore();
}
}
@Override
public void drawChassis(Canvas canvas) {
canvas.save();
canvas.translate(getX(), getY());
canvas.rotate(MathUtils.toDegrees(getHeading()) + 90);
canvas.drawLines(outline, paint);
canvas.drawCircle(0f, 0f, 5f, paint);
canvas.restore();
if (!firing) {
float radius = POWER_CIRCLE_RADIUS * powerLevel / MAX_POWER_LEVEL;
if (radius > 0) {
tempPaint.set(paint);
paint.setStyle(Style.FILL);
paint.setColor(Color.GRAY);
canvas.drawCircle(getX(), getY(), radius, paint);
paint.set(tempPaint);
}
}
}
/**
* Pinta la figura
*
* @param canvas
*/
public void draw(Canvas canvas) {
canvas.save();
this.tr.applyTransformations(canvas);
canvas.drawOval(rectElement, paint);
canvas.drawOval(rectElement, paintBorder);
canvas.restore();
}
/**
* 重叠合并两张图片，合并后的大小等同于作为底图的图片大小
*
* @param background：下层图，即底图
* @param foreground：上层图，即前置图
* @return 合并后的Bitmap
*/
public static Bitmap toConformBitmap(Bitmap background, Bitmap foreground, Paint paint) {
if (null == background) {
return null;
}
int bgWidth = background.getWidth();
int bgHeight = background.getHeight();
// int fgWidth = foreground.getWidth();
// int fgHeight = foreground.getHeight();
// create the new blank bitmap 创建一个新的和SRC长度宽度一样的位图
Bitmap newbmp = null;
try {
newbmp = Bitmap.createBitmap(bgWidth, bgHeight, Config.ARGB_8888);
} catch (OutOfMemoryError e) {
// OOM,return null
return null;
}
Canvas cv = new Canvas(newbmp);
// draw bg into
cv.drawBitmap(background, 0, 0, paint); // 在 0，0坐标开始画入bg
// draw fg into
if (null != foreground) {
cv.drawBitmap(foreground, 0, 0, paint); // 在 0，0坐标开始画入fg ，可以从任意位置画入
}
// save all clip
cv.save(Canvas.ALL_SAVE_FLAG); // 保存
// store
cv.restore(); // 存储
return newbmp;
}
@Override
protected void onDraw(Canvas canvas) {
if (currentMessageObject == null) {
return;
}
Drawable backgroundDrawable;
if (ApplicationLoader.isCustomTheme()) {
backgroundDrawable = ResourceLoader.backgroundBlack;
} else {
backgroundDrawable = ResourceLoader.backgroundBlue;
}
backgroundDrawable.setBounds(
textX - AndroidUtilities.dp(5),
AndroidUtilities.dp(5),
textX + textWidth + AndroidUtilities.dp(5),
AndroidUtilities.dp(9) + textHeight);
backgroundDrawable.draw(canvas);
if (currentMessageObject.type == 11) {
imageReceiver.draw(canvas);
}
if (textLayout != null) {
canvas.save();
canvas.translate(textXLeft, textY);
textLayout.draw(canvas);
canvas.restore();
}
}
