// ==============================================================================
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;
}
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
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();
}
}
}
void myDraw() {
float width, height;
width = getMeasuredWidth();
height = getMeasuredHeight();
canvas = holder.lockCanvas();
canvas.drawColor(Color.GREEN);
canvas.drawPath(path, paint);
holder.unlockCanvasAndPost(canvas);
}
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);
}
/**
* ************************************************************** put text in figure coordinates
* (0,0) is bottom left side. **************************************************************
*/
private void textFigure(String txt, float x, float y, float deg, Canvas canvas) {
mPlotPaint.setStrokeWidth(0);
if (deg != 0) {
canvas.save();
canvas.rotate(deg, x, y);
}
canvas.drawText(txt, x, y, mPlotPaint);
if (deg != 0) {
canvas.restore();
}
}
/**
* 画左右侧的边界区域（将超出的chart图形覆盖）
*
* @param canvas
*/
private void drawLimitRect(Canvas canvas) {
Paint paint = new Paint();
paint.setColor(backColor);
paint.setStyle(Style.FILL);
canvas.drawRect(0, 0, leftPadding + yTextWidth, height - bottomPadding, paint);
canvas.drawRect(width - rightPadding, 0, width, height - bottomPadding, paint);
}
private void drawFooter(Canvas canvas) {
final ZLView view = ZLApplication.Instance().getCurrentView();
final ZLView.FooterArea footer = view.getFooterArea();
if (footer == null) {
myFooterBitmap = null;
return;
}
if (myFooterBitmap != null
&& (myFooterBitmap.getWidth() != getWidth()
|| myFooterBitmap.getHeight() != footer.getHeight())) {
myFooterBitmap = null;
}
if (myFooterBitmap == null) {
myFooterBitmap = Bitmap.createBitmap(getWidth(), footer.getHeight(), Bitmap.Config.RGB_565);
}
final ZLAndroidPaintContext context =
new ZLAndroidPaintContext(
new Canvas(myFooterBitmap),
getWidth(),
footer.getHeight(),
view.isScrollbarShown() ? getVerticalScrollbarWidth() : 0);
footer.paint(context);
canvas.drawBitmap(myFooterBitmap, 0, getHeight() - footer.getHeight(), myPaint);
}
/**
* 画整体chart图
*
* @param translatX chart图偏移量
*/
public void refreshChart(int translatX) {
synchronized (holder) {
translationChart(translatX);
if (holder != null) {
Canvas canvas = holder.lockCanvas();
if (canvas != null) {
canvas.drawColor(backColor);
drawGridLine(canvas);
drawChartLine(canvas);
drawLimitRect(canvas);
drawAxesLine(canvas);
drawYValueText(canvas);
holder.unlockCanvasAndPost(canvas);
}
}
}
}
public void mDraw() {
mCanvas = mHolder.lockCanvas(); // 获得画布对象,开始对画布画画
mCanvas.drawColor(++i); // 设置画布颜色为黑色
canvasMethod(mCanvas); // 调用自定义的方法,主要是在传进去的画布对象上画画
mHolder.unlockCanvasAndPost(mCanvas); // 把画布显示在屏幕上
}
/**
* 画X，Y轴和边框
*
* @param canvas
*/
private void drawAxesLine(Canvas canvas) {
XYpaint = new Paint();
XYpaint.setColor(axesLineColor);
XYpaint.setAntiAlias(true);
XYpaint.setStyle(Style.FILL_AND_STROKE);
XYpaint.setStrokeWidth(chartFrameLineSize);
// 左侧Y轴
canvas.drawLine(
leftPadding + yTextWidth,
topPadding + topTextHeight,
leftPadding + yTextWidth,
height - bottomPadding - xTextHeight,
XYpaint);
// 三角箭头
Path yTriangle = new Path();
yTriangle.moveTo(leftPadding + yTextWidth - 10, topPadding + topTextHeight);
yTriangle.lineTo(leftPadding + yTextWidth, topPadding + topTextHeight - 20);
yTriangle.lineTo(leftPadding + yTextWidth + 10, topPadding + topTextHeight);
yTriangle.close();
canvas.drawPath(yTriangle, XYpaint);
// 下方X轴
canvas.drawLine(
leftPadding + yTextWidth,
height - bottomPadding - xTextHeight,
width - rightPadding,
height - bottomPadding - xTextHeight,
XYpaint);
// 三角箭头
Path xTriangle = new Path();
xTriangle.moveTo(width - rightPadding, height - bottomPadding - xTextHeight + 10);
xTriangle.lineTo(width - rightPadding + 15, height - bottomPadding - xTextHeight);
xTriangle.lineTo(width - rightPadding, height - bottomPadding - xTextHeight - 10);
xTriangle.close();
canvas.drawPath(xTriangle, XYpaint);
// 上方封顶
// canvas.drawLine(leftPadding + xTextHeight, topPadding + topTextHeight, width - rightPadding,
// topPadding + topTextHeight, XYpaint);
// 右侧封边
// canvas.drawLine(width - rightPadding, topPadding + topTextHeight, width - rightPadding,
// height - bottomPadding - xTextHeight, XYpaint);
}
/**
* Y周的刻度值
*
* @param canvas
*/
private void drawYValueText(Canvas canvas) {
Paint paint = new Paint();
paint.setColor(axesLineColor);
paint.setAntiAlias(true);
paint.setSubpixelText(true);
paint.setTypeface(Typeface.MONOSPACE);
paint.setTextSize(leftTextSize);
paint.setTextAlign(Align.RIGHT);
/*int yHeight = height - topPadding - bottomPadding - topTextHeight;
int spaceLength = yHeight / yNum;
int spaceValue = (yMaxValue - yMinValue) / yNum;
for (int i = 0; i < 6; i++) {
canvas.drawText((yMinValue + spaceValue * i) + "", leftPadding + yTextWidth - 5, height - bottomPadding - yTextWidth - (spaceLength * i),
paint);
}*/
canvas.drawText(
"优秀",
leftPadding + (yTextWidth + leftTextSize) / 2,
height - bottomPadding - xTextHeight - (spaceYLength * 5) + leftTextSize / 2,
paint);
canvas.drawText(
"良好",
leftPadding + (yTextWidth + leftTextSize) / 2,
height - bottomPadding - xTextHeight - (spaceYLength * 4) + leftTextSize / 2,
paint);
canvas.drawText(
"一般",
leftPadding + (yTextWidth + leftTextSize) / 2,
height - bottomPadding - xTextHeight - (spaceYLength * 3) + leftTextSize / 2,
paint);
canvas.drawText(
"差劲",
leftPadding + (yTextWidth + leftTextSize) / 2,
height - bottomPadding - xTextHeight - (spaceYLength * 2) + leftTextSize / 2,
paint);
canvas.drawText(
"恶劣",
leftPadding + (yTextWidth + leftTextSize) / 2,
height - bottomPadding - xTextHeight - (spaceYLength * 1) + leftTextSize / 2,
paint);
}
protected void onDraw(Canvas cs) {
super.onDraw(cs);
// 描画方法の設定
Paint p = new Paint();
p.setColor(Color.BLACK);
p.setStyle(Paint.Style.FILL);
p.setStrokeWidth(8);
// 円の描画
cs.drawCircle(x, y, 50, p);
}
// 그리기
void Draw(Canvas canvas) {
Paint pnt = new Paint();
pnt.setAntiAlias(true);
int r;
int alpha;
for (r = rad, alpha = 1; r > 4; r--, alpha += 5) {
pnt.setColor(Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color)));
canvas.drawCircle(x, y, r, pnt);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (Build.VERSION.SDK_INT < 11) {
mTransform.set(canvas.getMatrix());
mTransform.preRotate(mRotation, mPivot.x, mPivot.y);
canvas.setMatrix(mTransform);
}
for (Item it : mData) {
mPiePaint.setShader(it.mItemShader);
cSlicePaint.setShader(it.cSliceShader);
// Log.d(TAG, "mBounds: " +mBounds);
canvas.drawArc(mBounds, 360 - it.mEndAngle, it.mEndAngle - it.mStartAngle, true, mPiePaint);
Log.d(TAG, "Item Being Built: " + it.mLabel);
Log.d(TAG, "RectF: " + it.cSliceBounds);
Log.d(TAG, "StartAngle> " + it.mStartAngle + " EndAngle> " + it.mEndAngle);
canvas.drawArc(
it.cSliceBounds, 360 - it.mEndAngle, it.mEndAngle - it.mStartAngle, true, cSlicePaint);
// Log.d(TAG, "StartAngle> "+it.mStartAngle+" EndAngle> "+it.mEndAngle);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (paint == null) {
paint = new Paint();
luar =
new LinearGradient(
0.f, 0.f, 0.f, this.getMeasuredHeight(), 0xffffffff, 0xff000000, TileMode.CLAMP);
}
int rgb = Color.HSVToColor(color);
Shader dalam =
new LinearGradient(0.f, 0.f, this.getMeasuredWidth(), 0.f, 0xffffffff, rgb, TileMode.CLAMP);
ComposeShader shader = new ComposeShader(luar, dalam, PorterDuff.Mode.MULTIPLY);
paint.setShader(shader);
canvas.drawRect(0.f, 0.f, this.getMeasuredWidth(), this.getMeasuredHeight(), paint);
}
/**
* 背景画网格的横线
*
* @param canvas
*/
private void drawGridLine(Canvas canvas) {
Paint paint = new Paint();
paint.setColor(gridLineColor);
paint.setAntiAlias(true);
paint.setStyle(Style.STROKE);
paint.setStrokeWidth(gridLineSize);
paint.setPathEffect(new DashPathEffect(new float[] {10, 20}, 0));
for (int i = 1; i <= yNum; i++) {
// 画网格的横线
canvas.drawLine(
leftPadding + yTextWidth,
height - bottomPadding - xTextHeight - (spaceYLength * i),
width - rightPadding,
height - bottomPadding - xTextHeight - (spaceYLength * i),
paint);
}
}
private void onDrawStatic(final Canvas canvas) {
myBitmapManager.setSize(getWidth(), getMainAreaHeight());
canvas.drawBitmap(myBitmapManager.getBitmap(ZLView.PageIndex.current), 0, 0, myPaint);
drawFooter(canvas);
new Thread() {
@Override
public void run() {
final ZLView view = ZLApplication.Instance().getCurrentView();
final ZLAndroidPaintContext context =
new ZLAndroidPaintContext(
canvas,
getWidth(),
getMainAreaHeight(),
view.isScrollbarShown() ? getVerticalScrollbarWidth() : 0);
view.preparePage(context, ZLView.PageIndex.next);
}
}.start();
}
public void onDraw(Canvas canvas) {
canvas.drawColor(Color.LTGRAY);
Paint Pnt = new Paint();
int y = 1;
Pnt.setAntiAlias(true);
Pnt.setTextSize(30);
Pnt.setTypeface(Typeface.create(Typeface.DEFAULT, Typeface.NORMAL));
canvas.drawText("Font:Default", 10, y++ * 40, Pnt);
Pnt.setTypeface(Typeface.create(Typeface.DEFAULT_BOLD, Typeface.NORMAL));
canvas.drawText("Font:Default Bold", 10, y++ * 40, Pnt);
Pnt.setTypeface(Typeface.create(Typeface.MONOSPACE, Typeface.NORMAL));
canvas.drawText("Font:Monospace", 10, y++ * 40, Pnt);
Pnt.setTypeface(Typeface.create(Typeface.SANS_SERIF, Typeface.NORMAL));
canvas.drawText("Font:Sans Serif", 10, y++ * 40, Pnt);
Pnt.setTypeface(Typeface.create(Typeface.SERIF, Typeface.NORMAL));
canvas.drawText("Font:Serif", 10, y++ * 40, Pnt);
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
// draw border
mPlotPaint.setStyle(Paint.Style.STROKE);
mPlotPaint.setColor(Color.BLACK);
canvas.drawRect(mPlotBounds, mPlotPaint);
// draw grid
mPlotPaint.setColor(gridColor);
// x grid
if (xTicks != null) {
for (float tick : xTicks) {
int x = calcX(tick);
canvas.drawLine(x, mPlotBounds.bottom, x, mPlotBounds.top, mPlotPaint);
}
}
if (yTicks != null) {
for (float tick : yTicks) {
int y = calcY(tick);
canvas.drawLine(mPlotBounds.left, y, mPlotBounds.right, y, mPlotPaint);
}
}
/* *************************
* draw the data
***************************/
for (Seria s : mData) {
stroke(s, canvas);
}
// draw rectangles that hide out of bounds lines
mPlotPaint.setStyle(Style.FILL);
mPlotPaint.setColor(Color.WHITE);
// left
canvas.drawRect(0, 0, mPlotBounds.left, this.getBottom(), mPlotPaint);
// bottom
canvas.drawRect(0, mPlotBounds.bottom + 1, this.getRight(), this.getBottom(), mPlotPaint);
// right
canvas.drawRect(mPlotBounds.right + 1, 0, this.getRight(), this.getBottom(), mPlotPaint);
// top
canvas.drawRect(0, 0, this.getRight(), mPlotBounds.top, mPlotPaint);
// x ticks
mPlotPaint.setStyle(Paint.Style.STROKE);
mPlotPaint.setTextAlign(Align.CENTER);
mPlotPaint.setTextSize(xTickTextHeight);
mPlotPaint.setColor(xTickColor);
if (xTicks != null) {
for (float tick : xTicks) {
textFigure(
xTickFormat.format(tick).toString(),
calcX(tick),
mPlotBounds.bottom + xTickTextHeight,
canvas);
}
}
mPlotPaint.setTextSize(labelTextHeight);
mPlotPaint.setTextAlign(Align.RIGHT);
if (labelX != null) {
textFigure(labelX, mPlotBounds.right, mPlotBounds.bottom + axisXSpacing, canvas);
}
// y ticks
mPlotPaint.setTextAlign(Align.CENTER);
mPlotPaint.setTextSize(yTickTextHeight);
mPlotPaint.setColor(yTickColor);
if (yTicks != null) {
for (float tick : yTicks) {
textFigure(
yTickFormat.format(tick).toString(),
mPlotBounds.left - yTickTextHeight,
calcY(tick),
90,
canvas);
}
}
mPlotPaint.setTextSize(labelTextHeight);
mPlotPaint.setTextAlign(Align.RIGHT);
if (labelX != null) {
textFigure(labelX, mPlotBounds.right, mPlotBounds.bottom + axisXSpacing, canvas);
}
mPlotPaint.setTextAlign(Align.LEFT);
if (labelY != null) {
textFigure(labelY, mPlotBounds.left - axisYSpacing, mPlotBounds.top, 90, canvas);
}
}
@Override
protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
final boolean ret;
final Integer row = (Integer) child.getTag(R.id.tag_row);
final Integer column = (Integer) child.getTag(R.id.tag_column);
// row == null => Shadow view
if (row == null || (row == -1 && column == -1)) {
ret = super.drawChild(canvas, child, drawingTime);
} else {
canvas.save();
if (row == -1) {
canvas.clipRect(widths[0], 0, canvas.getWidth(), canvas.getHeight());
} else if (column == -1) {
canvas.clipRect(0, heights[0], canvas.getWidth(), canvas.getHeight());
} else {
canvas.clipRect(widths[0], heights[0], canvas.getWidth(), canvas.getHeight());
}
ret = super.drawChild(canvas, child, drawingTime);
canvas.restore();
}
return ret;
}
/**
* 自定义的方法,简单绘制一些基本图形
*
* @param mCanvas 把图形画在mCanvas上
*/
public void canvasMethod(Canvas mCanvas) {
// 创建对应坐标的矩形区域
RectF mArc = new RectF(mX, mY - 70, mX + 50, mY - 20);
// 画填充弧,在矩形区域内,从弧的最右边开始,画270度,然后再通过连接圆心来填充
mCanvas.drawArc(mArc, 0, 270, true, mPaint);
// 获得icon的Bitmap对象
Bitmap mBitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
// 画图片
mCanvas.drawBitmap(mBitmap, mX, mY, mPaint);
// 画圆,(x轴,y轴,半径,画笔)
mCanvas.drawCircle(mX + 10, mY + 60, 10, mPaint);
// 画一条线,(起点横坐标,起点纵坐标,终点横坐标,终点纵坐标,画笔)
mCanvas.drawLine(mX, mY + 75, mX + 20, mY + 75, mPaint);
// 画多条线,(坐标数组,画笔)坐标数组里每四个值构成一条线
mCanvas.drawLines(
new float[] {mX + 50, mY + 45, mX + 50, mY + 75, mX + 60, mY + 45, mX + 60, mY + 75},
mPaint);
// 创建对应矩形区域
RectF mOval = new RectF(mX, mY + 80, mX + 60, mY + 110);
// 画椭圆
mCanvas.drawOval(mOval, mPaint);
/*
* Paint qPaint = new Paint(); qPaint.setColor(Color.RED);
* mCanvas.drawPaint(qPaint);
*/
// 重置Path里的所有路径
mPath.reset();
// 设置Path的起点
mPath.moveTo(mX, mY + 120);
// 第二个点
mPath.lineTo(screenW - 10, mY + 120);
// 第三个点
mPath.lineTo(screenW - 10, mY + 150);
// 画出路径,这里画的是三角形
mCanvas.drawPath(mPath, mPaint);
// 重置Path里的所有路径
qPath.reset();
// 设置Path的起点
qPath.moveTo(qStartX, qStartY);
// 设置贝塞尔曲线的控制点坐标和终点坐标
qPath.quadTo(qControlX, qCOntrolY, qEndX, qEndY);
// 画出贝塞尔曲线
mCanvas.drawPath(qPath, qPaint);
// 画点
mCanvas.drawPoint(mX, mY + 155, qPaint);
// 画多个点,坐标数组每两个值代表一个点的坐标
mCanvas.drawPoints(new float[] {mX, mY + 160, mX + 5, mY + 160, mX + 5, mY + 160}, qPaint);
// 画矩形
mCanvas.drawRect(mX, mY + 170, mX + 100, mY + 220, mPaint);
// 设置矩形区域
RectF mRect = new RectF(mX, mY + 230, mX + 100, mY + 260);
// 画圆角矩形,这个方法的第二第三个参数在后面有图讲解
mCanvas.drawRoundRect(mRect, 10, 10, mPaint);
// 画文本
mCanvas.drawText("drawText", mX, mY + 290, mPaint);
// 画文本,数组里每两个值代表文本的一个字符的坐标，数组的坐标可以比字符串里的字符多，但不可以少
mCanvas.drawPosText(
"哈哈你好",
new float[] {mX, mY + 310, mX + 20, mY + 310, mX + 40, mY + 310, mX + 60, mY + 310},
mPaint);
// 重置Path
tPath.reset();
// 添加一个圆形路径,坐标,半径,方向(顺时针还是逆时针)
tPath.addCircle(mX + 10, mY + 340, 10, Path.Direction.CW);
// 画出路径
mCanvas.drawPath(tPath, qPaint);
// 把文本画在路径上,但不会画出路径
mCanvas.drawTextOnPath("draw", tPath, 30, 0, mPaint);
}
/**
* 画折线图，网格竖线，X坐标值
*
* @param canvas
*/
private void drawChartLine(Canvas canvas) {
Paint paintChart = new Paint();
paintChart.setColor(chartLineColor);
paintChart.setAntiAlias(true);
paintChart.setStyle(Style.STROKE);
paintChart.setStrokeWidth(chartLineSize);
Paint paintGrid = new Paint();
paintGrid.setColor(gridLineColor);
paintGrid.setAntiAlias(true);
paintGrid.setStyle(Style.STROKE);
paintGrid.setStrokeWidth(gridLineSize);
Paint paintTopText = new Paint();
paintTopText.setColor(axesLineColor);
paintTopText.setAntiAlias(true);
paintTopText.setSubpixelText(true);
paintTopText.setTypeface(Typeface.MONOSPACE);
paintTopText.setTextSize(topTextSize);
paintTopText.setTextAlign(Align.CENTER);
Paint paintBottomText = new Paint();
paintBottomText.setColor(axesLineColor);
paintBottomText.setAntiAlias(true);
paintBottomText.setSubpixelText(true);
paintBottomText.setTypeface(Typeface.MONOSPACE);
paintBottomText.setTextSize(bottomTextSize);
paintBottomText.setTextAlign(Align.CENTER);
Paint paintPoint = new Paint();
paintPoint.setColor(pointColor);
paintPoint.setAntiAlias(true);
paintPoint.setStyle(Style.FILL);
pressedPaint = new Paint();
pressedPaint.setColor(pressedColor);
pressedPaint.setAntiAlias(true);
pressedPaint.setStyle(Style.FILL);
Paint paintShape = new Paint();
paintShape.setStyle(Style.FILL);
paintShape.setColor(shapeColor);
paintShape.setAlpha(shapeAlpha);
if (axesData.size() > 0) {
for (int i = 0; i < axesData.size(); i++) {
if (i < axesData.size() - 1) {
// 画折线
canvas.drawLine(
axesData.get(i).X,
axesData.get(i).Y,
axesData.get(i + 1).X,
axesData.get(i + 1).Y,
paintChart);
if (isShapeShow) {
// 画阴影
Path path = new Path();
path.moveTo(axesData.get(i).X, height - bottomPadding - xTextHeight);
path.lineTo(axesData.get(i).X, axesData.get(i).Y + chartLineSize / 2);
path.lineTo(axesData.get(i + 1).X, axesData.get(i + 1).Y + chartLineSize / 2);
path.lineTo(axesData.get(i + 1).X, height - bottomPadding - xTextHeight);
canvas.drawPath(path, paintShape);
}
}
// 画网格竖线
// canvas.drawLine(axesData.get(i).X, height - bottomPadding - xTextHeight,
// axesData.get(i).X, topPadding + topTextHeight, paintGrid);
// 写X轴坐标的刻度值
if (!TextUtils.isEmpty(axesData.get(i).getxText())) {
setTextSizeForWidth(
paintBottomText, spaceXLength - 10, axesData.get(i).getxText()); // 10为相邻日期文字间隔
canvas.drawText(
axesData.get(i).getxText(),
axesData.get(i).X,
height - bottomPadding - xTextHeight / 2,
paintBottomText);
}
// 写顶部的刻度值
if (!TextUtils.isEmpty(axesData.get(i).getTopText())) {
// 取消了顶部隔年显示的数据
// canvas.drawText(axesData.get(i).getTopText(), axesData.get(i).X, topPadding,
// paintTopText);
}
// 画数据点
if (pointBitmap == null) {
canvas.drawCircle(axesData.get(i).X, axesData.get(i).Y, pointSize + 1, paintChart);
canvas.drawCircle(axesData.get(i).X, axesData.get(i).Y, pointSize, paintPoint);
} else {
Matrix matrix = new Matrix();
canvas.drawBitmap(pointBitmap, matrix, paintPoint);
}
}
// 画最后一个数据的网格竖线
// canvas.drawLine(axesData.get(axesData.size() - 1).X, height - bottomPadding - xTextHeight,
// axesData.get(axesData.size() - 1).X,
// topPadding + topTextHeight, paintGrid);
// 写X轴坐标的最后一个值的刻度值
/*
* canvas.drawText(axesData.get(axesData.size() - 1).X + "",
* axesData.get(axesData.size() - 1).X, height - bottomPadding -
* xTextHeight / 2, paintBottomText);
*/
// 写顶部的最后一个刻度值
// canvas.drawText("2014", axesData.get(axesData.size() - 1).X,
// topPadding, paintTopText);
// 画数最后一个据点
if (pointBitmap == null) {
// canvas.drawCircle(axesData.get(axesData.size() - 1).X,
// axesData.get(axesData.size() - 1).Y, pointSize + 1,
// paintChart);
// canvas.drawCircle(axesData.get(axesData.size() - 1).X,
// axesData.get(axesData.size() - 1).Y, pointSize, paintPoint);
} else {
Matrix matrix = new Matrix();
canvas.drawBitmap(pointBitmap, matrix, paintPoint);
}
}
if (currentPressedPoint != null) {
// canvas.drawCircle(currentPressedPoint.X, currentPressedPoint.Y, pointSize, pressedPaint);
}
}
// 화면 그리기
public void onDraw(Canvas canvas) {
canvas.drawBitmap(mBack, 0, 0, null);
for (int idx = 0; idx < arBall.size(); idx++) {
arBall.get(idx).Draw(canvas);
}
}
public void onDraw(Canvas canvas) {
Paint p = new Paint();
p.setColor(Color.GREEN);
canvas.drawCircle(x, y, 16, p);
}
@Override
protected void onDraw(Canvas canvas) {
canvas.drawLine(mTextX, mPointerY, mPointerX, mPointerY, mTextPaint);
canvas.drawCircle(mPointerX, mPointerY, mPointerRadius, mTextPaint);
}
private void stroke(Seria s, Canvas canvas) {
mPlotPaint.setStyle(Paint.Style.STROKE);
// draw line
if (s.mWidth > 0) {
// create the path
mPath.reset();
mPath.moveTo(calcX(s.x[0]), calcY(s.y[0]));
for (int i = 1; i < s.sz(); i++) {
mPath.lineTo(calcX(s.x[i]), calcY(s.y[i]));
}
// draw the path
mPlotPaint.setColor(s.mColor);
mPlotPaint.setStrokeWidth(s.mWidth);
mPlotPaint.setPathEffect(s.mEffect);
canvas.drawPath(mPath, mPlotPaint);
}
// draw images seria
if (s.bms != null) {
for (int i = 0; i < s.sz(); i++) {
Bitmap bm;
if (s.bms.length > 1) {
bm = s.bms[i];
} else {
bm = s.bms[0];
}
float left = calcX(s.x[i]);
float top = calcY(s.y[i]);
if (s.hAlign == HALIGN.CENTER) {
left -= bm.getWidth() / 2;
} else if (s.hAlign == HALIGN.RIGHT) {
left -= bm.getWidth();
}
if (s.vAlign == VALIGN.CENTER) {
top -= bm.getHeight() / 2;
} else if (s.vAlign == VALIGN.BOTTOM) {
top -= bm.getHeight();
}
canvas.drawBitmap(s.bms[i], left, top, mPlotPaint);
}
}
if (s.texts != null) {
Align align = Align.CENTER;
switch (s.hAlign) {
case LEFT:
align = Align.RIGHT;
case RIGHT:
align = Align.LEFT;
}
mPlotPaint.setTextAlign(align);
mPlotPaint.setStrokeWidth(0);
mPlotPaint.setColor(s.mColor);
for (int i = 0; i < s.sz(); i++) {
float x = calcX(s.x[i]);
float y = calcY(s.y[i]);
switch (s.vAlign) {
case TOP:
y -= mPlotPaint.getTextSize();
case CENTER:
y -= 0.5 * mPlotPaint.getTextSize();
}
if (s.deg != 0) {
canvas.save();
canvas.rotate(s.deg, x, y);
}
canvas.drawText(s.texts[i], x, y, mPlotPaint);
if (s.deg != 0) {
canvas.restore();
}
}
}
}
@Override
protected void onDraw(Canvas canvas) {
mDrawable.setBounds(mRect);
float r = 16;
canvas.save();
canvas.translate(10, 10);
mDrawable.setGradientType(GradientDrawable.LINEAR_GRADIENT);
setCornerRadii(mDrawable, r, r, 0, 0);
mDrawable.draw(canvas);
canvas.restore();
canvas.save();
canvas.translate(10 + mRect.width() + 10, 10);
mDrawable.setGradientType(GradientDrawable.RADIAL_GRADIENT);
setCornerRadii(mDrawable, 0, 0, r, r);
mDrawable.draw(canvas);
canvas.restore();
canvas.translate(0, mRect.height() + 10);
canvas.save();
canvas.translate(10, 10);
mDrawable.setGradientType(GradientDrawable.SWEEP_GRADIENT);
setCornerRadii(mDrawable, 0, r, r, 0);
mDrawable.draw(canvas);
canvas.restore();
canvas.save();
canvas.translate(10 + mRect.width() + 10, 10);
mDrawable.setGradientType(GradientDrawable.LINEAR_GRADIENT);
setCornerRadii(mDrawable, r, 0, 0, r);
mDrawable.draw(canvas);
canvas.restore();
canvas.translate(0, mRect.height() + 10);
canvas.save();
canvas.translate(10, 10);
mDrawable.setGradientType(GradientDrawable.RADIAL_GRADIENT);
setCornerRadii(mDrawable, r, 0, r, 0);
mDrawable.draw(canvas);
canvas.restore();
canvas.save();
canvas.translate(10 + mRect.width() + 10, 10);
mDrawable.setGradientType(GradientDrawable.SWEEP_GRADIENT);
setCornerRadii(mDrawable, 0, r, 0, r);
mDrawable.draw(canvas);
canvas.restore();
}
@Override
protected void onDraw(Canvas canvas) {
float ringWidth = textHeight + 4;
int height = getMeasuredHeight();
int width = getMeasuredWidth();
int px = width / 2;
int py = height / 2;
Point center = new Point(px, py);
int radius = Math.min(px, py) - 2;
RectF boundingBox =
new RectF(center.x - radius, center.y - radius, center.x + radius, center.y + radius);
RectF innerBoundingBox =
new RectF(
center.x - radius + ringWidth,
center.y - radius + ringWidth,
center.x + radius - ringWidth,
center.y + radius - ringWidth);
float innerRadius = innerBoundingBox.height() / 2;
RadialGradient borderGradient =
new RadialGradient(
px, py, radius, borderGradientColors, borderGradientPositions, TileMode.CLAMP);
Paint pgb = new Paint();
pgb.setShader(borderGradient);
Path outerRingPath = new Path();
outerRingPath.addOval(boundingBox, Direction.CW);
canvas.drawPath(outerRingPath, pgb);
LinearGradient skyShader =
new LinearGradient(
center.x,
innerBoundingBox.top,
center.x,
innerBoundingBox.bottom,
skyHorizonColorFrom,
skyHorizonColorTo,
TileMode.CLAMP);
Paint skyPaint = new Paint();
skyPaint.setShader(skyShader);
LinearGradient groundShader =
new LinearGradient(
center.x,
innerBoundingBox.top,
center.x,
innerBoundingBox.bottom,
groundHorizonColorFrom,
groundHorizonColorTo,
TileMode.CLAMP);
Paint groundPaint = new Paint();
groundPaint.setShader(groundShader);
float tiltDegree = pitch;
while (tiltDegree > 90 || tiltDegree < -90) {
if (tiltDegree > 90) tiltDegree = -90 + (tiltDegree - 90);
if (tiltDegree < -90) tiltDegree = 90 - (tiltDegree + 90);
}
float rollDegree = roll;
while (rollDegree > 180 || rollDegree < -180) {
if (rollDegree > 180) rollDegree = -180 + (rollDegree - 180);
if (rollDegree < -180) rollDegree = 180 - (rollDegree + 180);
}
Path skyPath = new Path();
skyPath.addArc(innerBoundingBox, -rollDegree, (180 + (2 * rollDegree)));
canvas.rotate(-tiltDegree, px, py);
canvas.drawOval(innerBoundingBox, groundPaint);
canvas.drawPath(skyPath, skyPaint);
canvas.drawPath(skyPath, markerPaint);
int markWidth = radius / 3;
int startX = center.x - markWidth;
int endX = center.x + markWidth;
Log.d("PAARV ", "Roll " + String.valueOf(rollDegree));
Log.d("PAARV ", "Pitch " + String.valueOf(tiltDegree));
double h = innerRadius * Math.cos(Math.toRadians(90 - tiltDegree));
double justTiltX = center.x - h;
float pxPerDegree = (innerBoundingBox.height() / 2) / 45f;
for (int i = 90; i >= -90; i -= 10) {
double ypos = justTiltX + i * pxPerDegree;
if ((ypos < (innerBoundingBox.top + textHeight))
|| (ypos > innerBoundingBox.bottom - textHeight)) continue;
canvas.drawLine(startX, (float) ypos, endX, (float) ypos, markerPaint);
int displayPos = (int) (tiltDegree - i);
String displayString = String.valueOf(displayPos);
float stringSizeWidth = textPaint.measureText(displayString);
canvas.drawText(
displayString, (int) (center.x - stringSizeWidth / 2), (int) (ypos) + 1, textPaint);
}
markerPaint.setStrokeWidth(2);
canvas.drawLine(
center.x - radius / 2,
(float) justTiltX,
center.x + radius / 2,
(float) justTiltX,
markerPaint);
markerPaint.setStrokeWidth(1);
Path rollArrow = new Path();
rollArrow.moveTo(center.x - 3, (int) innerBoundingBox.top + 14);
rollArrow.lineTo(center.x, (int) innerBoundingBox.top + 10);
rollArrow.moveTo(center.x + 3, innerBoundingBox.top + 14);
rollArrow.lineTo(center.x, innerBoundingBox.top + 10);
canvas.drawPath(rollArrow, markerPaint);
String rollText = String.valueOf(rollDegree);
double rollTextWidth = textPaint.measureText(rollText);
canvas.drawText(
rollText,
(float) (center.x - rollTextWidth / 2),
innerBoundingBox.top + textHeight + 2,
textPaint);
canvas.restore();
canvas.save();
canvas.rotate(180, center.x, center.y);
for (int i = -180; i < 180; i += 10) {
if (i % 30 == 0) {
String rollString = String.valueOf(i * -1);
float rollStringWidth = textPaint.measureText(rollString);
PointF rollStringCenter =
new PointF(center.x - rollStringWidth / 2, innerBoundingBox.top + 1 + textHeight);
canvas.drawText(rollString, rollStringCenter.x, rollStringCenter.y, textPaint);
} else {
canvas.drawLine(
center.x,
(int) innerBoundingBox.top,
center.x,
(int) innerBoundingBox.top + 5,
markerPaint);
}
canvas.rotate(10, center.x, center.y);
}
canvas.restore();
canvas.save();
canvas.rotate(-1 * (bearing), px, py);
double increment = 22.5;
for (double i = 0; i < 360; i += increment) {
CompassDirection cd = CompassDirection.values()[(int) (i / 22.5)];
String headString = cd.toString();
float headStringWidth = textPaint.measureText(headString);
PointF headStringCenter =
new PointF(center.x - headStringWidth / 2, boundingBox.top + 1 + textHeight);
if (i % increment == 0)
canvas.drawText(headString, headStringCenter.x, headStringCenter.y, textPaint);
else
canvas.drawLine(
center.x, (int) boundingBox.top, center.x, (int) boundingBox.top + 3, markerPaint);
canvas.rotate((int) increment, center.x, center.y);
}
canvas.restore();
RadialGradient glassShader =
new RadialGradient(
px, py, (int) innerRadius, glassGradientColors, glassGradientPositions, TileMode.CLAMP);
Paint glassPaint = new Paint();
glassPaint.setShader(glassShader);
canvas.drawOval(innerBoundingBox, glassPaint);
canvas.drawOval(boundingBox, circlePaint);
circlePaint.setStrokeWidth(2);
canvas.drawOval(innerBoundingBox, circlePaint);
canvas.restore();
}