@Override
public void drawHighlighted(Canvas c, Highlight[] indices) {
for (int i = 0; i < indices.length; i++) {
int xIndex = indices[i].getXIndex(); // get the
// x-position
CandleDataSet set = mChart.getCandleData().getDataSetByIndex(indices[i].getDataSetIndex());
if (set == null || !set.isHighlightEnabled()) continue;
mHighlightPaint.setColor(set.getHighLightColor());
CandleEntry e = set.getEntryForXIndex(xIndex);
if (e == null || e.getXIndex() != xIndex) continue;
float low = e.getLow() * mAnimator.getPhaseY();
float high = e.getHigh() * mAnimator.getPhaseY();
float min = mChart.getYChartMin();
float max = mChart.getYChartMax();
float[] vertPts =
new float[] {
xIndex - 0.5f, max, xIndex - 0.5f, min, xIndex + 0.5f, max, xIndex + 0.5f, min
};
float[] horPts =
new float[] {
mChart.getXChartMin(),
low,
mChart.getXChartMax(),
low,
mChart.getXChartMin(),
high,
mChart.getXChartMax(),
high
};
mChart.getTransformer(set.getAxisDependency()).pointValuesToPixel(vertPts);
mChart.getTransformer(set.getAxisDependency()).pointValuesToPixel(horPts);
// draw the vertical highlight lines
c.drawLines(vertPts, mHighlightPaint);
// draw the horizontal highlight lines
c.drawLines(horPts, mHighlightPaint);
}
}
/** 这个方法会在初始化后背调用一次,invaildate()的时候会被调用 */
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
Paint paint = new Paint(); // 设置一个笔
paint.setAntiAlias(true); // 设置没有锯齿
paint.setColor(Color.RED); // 设置笔的颜色
canvas.drawCircle(paintX, paintY, radius, paint); // 距离画圆
paint.setColor(Color.BLUE);
paint.setStrokeWidth(4);
paint.setStyle(Paint.Style.STROKE);
paint.setColor(Color.RED); // 设置笔的颜色
paint.setTextSize(50);
canvas.drawLines(points1, paint);
if (switch_info == true) {
canvas.drawText(String.valueOf(ori_acc), 10, 50, paint);
canvas.drawText(String.valueOf(orientationA), 300, 50, paint);
canvas.drawText(String.valueOf(ori_increment), 600, 50, paint);
canvas.drawText(String.valueOf(mean_oriacc), 10, 100, paint);
canvas.drawText(String.valueOf(mean_orisensor), 300, 100, paint);
canvas.drawText(String.valueOf(Step), 10, 150, paint);
canvas.drawText(String.valueOf(distance), 300, 150, paint);
}
}
@Override
protected void drawDaySeparators(Canvas canvas) {
float lines[] = new float[8 * 4];
int count = 6 * 4;
int wkNumOffset = 0;
int i = 0;
if (mShowWeekNum) {
// This adds the first line separating the week number
int xOffset = SPACING_WEEK_NUMBER + mPadding;
count += 4;
lines[i++] = xOffset;
lines[i++] = 0;
lines[i++] = xOffset;
lines[i++] = mHeight;
wkNumOffset++;
}
count += 4;
lines[i++] = 0;
lines[i++] = 0;
lines[i++] = mWidth;
lines[i++] = 0;
int y0 = 0;
int y1 = mHeight;
while (i < count) {
int x = computeDayLeftPosition(i / 4 - wkNumOffset);
lines[i++] = x;
lines[i++] = y0;
lines[i++] = x;
lines[i++] = y1;
}
p.setColor(mDaySeparatorInnerColor);
p.setStrokeWidth(DAY_SEPARATOR_INNER_WIDTH);
canvas.drawLines(lines, 0, count, p);
}
@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);
}
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (!active) {
return;
}
DownloadService downloadService = DownloadServiceImpl.getInstance();
if (downloadService != null && downloadService.getPlayerState() != PlayerState.STARTED) {
return;
}
if (data == null) {
return;
}
if (points == null || points.length < data.length * 4) {
points = new float[data.length * 4];
}
int w = getWidth();
int h = getHeight();
for (int i = 0; i < data.length - 1; i++) {
points[i * 4] = w * i / (data.length - 1);
points[i * 4 + 1] = h / 2 + ((byte) (data[i] + 128)) * (h / 2) / 128;
points[i * 4 + 2] = w * (i + 1) / (data.length - 1);
points[i * 4 + 3] = h / 2 + ((byte) (data[i + 1] + 128)) * (h / 2) / 128;
}
canvas.drawLines(points, paint);
}
public void draw(Canvas c) {
super.draw(c);
if (f_lines != null) {
c.drawLines(f_lines, paint);
}
c.drawLine(i_x, i_y, f_x, f_y, paint);
if (draw_ruler) {
c.drawLine(i_x_ruler, i_y_ruler, f_x_ruler, f_y_ruler, ruler_paint);
c.drawText(Float.toString(ruler_length), i_x_ruler, i_y_ruler, text_paint);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (mBytes == null) {
return;
}
if (mPoints == null || mPoints.length < mBytes.length * 4) {
mPoints = new float[mBytes.length * 40];
}
mRect.set(0, 0, getWidth(), getHeight());
//
final int baseX = mRect.width() / mSpectrumNum;
final int baseY = mRect.height() / linesnums;
final int height = mRect.height();
//
/* for (int i = 0; i < mSpectrumNum ; i++)
{
final int xi = baseX*i + baseX/2;
mPoints[i * 4] = xi;
mPoints[i * 4 + 1] = height;
mPoints[i * 4 + 2] = xi;
mPoints[i * 4 + 3] = height - (mBytes[i] /max) * height;
}
canvas.drawLines(mPoints,0,mSpectrumNum*4,mForePaint);*/
// for tsb ui
final int basex = mRect.width() / 10;
int total = 0;
for (int i = 0; i < 10; i++) {
final int x1 = basex * i + 1;
final int x2 = basex * (i + 1) - 3;
int num = (int) ((mBytes[i] / max) * linesnums);
for (int j = 0; j < num; j++) {
final int y1 = baseY * j + baseY / 2;
mPoints[total * 4] = x1;
mPoints[total * 4 + 1] = height - y1;
mPoints[total * 4 + 2] = x2;
mPoints[total * 4 + 3] = height - y1;
total++;
}
}
canvas.drawLines(mPoints, 0, total * 4, mForePaint);
}
/**
* Draws a line showing busy times in each day of week The method draws non-conflicting times in
* the event color and times with conflicting events in the dna conflict color defined in colors.
*
* @param canvas
*/
protected void drawDNA(Canvas canvas) {
// Draw event and conflict times
if (mDna != null) {
for (Utils.DNAStrand strand : mDna.values()) {
if (strand.color == CONFLICT_COLOR || strand.points == null || strand.points.length == 0) {
continue;
}
mDNATimePaint.setColor(strand.color);
canvas.drawLines(strand.points, mDNATimePaint);
}
// Draw black last to make sure it's on top
Utils.DNAStrand strand = mDna.get(CONFLICT_COLOR);
if (strand != null && strand.points != null && strand.points.length != 0) {
mDNATimePaint.setColor(strand.color);
canvas.drawLines(strand.points, mDNATimePaint);
}
if (mDayXs == null) {
return;
}
int numDays = mDayXs.length;
int xOffset = (DNA_ALL_DAY_WIDTH - DNA_WIDTH) / 2;
if (strand != null && strand.allDays != null && strand.allDays.length == numDays) {
for (int i = 0; i < numDays; i++) {
// this adds at most 7 draws. We could sort it by color and
// build an array instead but this is easier.
if (strand.allDays[i] != 0) {
mDNAAllDayPaint.setColor(strand.allDays[i]);
canvas.drawLine(
mDayXs[i] + xOffset,
DNA_MARGIN,
mDayXs[i] + xOffset,
DNA_MARGIN + DNA_ALL_DAY_HEIGHT,
mDNAAllDayPaint);
}
}
}
}
}
@Override
public void onRender(Canvas canvas, FFTData data, Rect rect) {
for (int i = 0; i < data.bytes.length / mDivisions; i++) {
mFFTPoints[i * 4] = i * 4 * mDivisions;
mFFTPoints[i * 4 + 2] = i * 4 * mDivisions;
byte rfk = data.bytes[mDivisions * i];
byte ifk = data.bytes[mDivisions * i + 1];
float magnitude = (rfk * rfk + ifk * ifk);
int dbValue = (int) (10 * Math.log10(magnitude));
mFFTPoints[i * 4 + 1] = rect.height();
mFFTPoints[i * 4 + 3] = rect.height() - (dbValue * mDbFuzzFactor + mDbFuzz);
}
canvas.drawLines(mFFTPoints, mPaint);
}
private void init(Context context) {
mContext = context;
mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
View v = LayoutInflater.from(context).inflate(R.layout.view_main, null);
compassView = (ImageView) v.findViewById(R.id.compass_view);
canvasView = (ImageView) v.findViewById(R.id.canvas_view);
// Resize canvasView
ResizeImageView.resizeImageView(
canvasView, ResolutionUtil.displayWidth(context), ResolutionUtil.displayWidth(context));
Bitmap bitmap =
Bitmap.createBitmap(
ResolutionUtil.displayWidth(context),
ResolutionUtil.displayHeight(context),
Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
// Draw transparent screen
Paint transPainter = new Paint();
transPainter.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.CLEAR));
canvas.drawRect(0, 0, bitmap.getWidth(), bitmap.getHeight(), transPainter);
Paint drawPaint = new Paint();
drawPaint.reset();
drawPaint.setFlags(Paint.DITHER_FLAG);
drawPaint.setAntiAlias(true);
drawPaint.setSubpixelText(true);
drawPaint.setColor(Color.GREEN);
drawPaint.setStyle(Paint.Style.STROKE);
drawPaint.setStrokeJoin(Paint.Join.ROUND);
drawPaint.setStrokeCap(Paint.Cap.ROUND);
drawPaint.setStrokeWidth(10);
canvas.drawLines(
new float[] {bitmap.getWidth() / 2, bitmap.getHeight() / 2, bitmap.getWidth() / 2, 0},
drawPaint);
canvasView.setImageBitmap(bitmap);
// invoke canvasView
canvasView.invalidate();
addView(v);
}
private void drawLineAndPoint(Canvas canvas) {
canvas.save();
canvas.translate(100, 100);
canvas.rotate(30);
mPaint.setAntiAlias(true);
mPaint.setColor(Color.RED);
mPaint.setStrokeWidth(2);
canvas.drawLines(points, mPaint);
mPaint.setColor(Color.BLUE);
mPaint.setStrokeWidth(5);
canvas.drawPoints(points, mPaint);
canvas.restore();
}
private Bitmap getPreviewBitmap(int color) {
final float density = getContext().getResources().getDisplayMetrics().density;
final int width = (int) (32 * density), height = (int) (32 * density);
final Bitmap bm = Bitmap.createBitmap(width, height, Config.ARGB_8888);
final Canvas canvas = new Canvas(bm);
final int rectrangle_size = (int) (density * 5);
final int numRectanglesHorizontal = (int) Math.ceil(width / rectrangle_size);
final int numRectanglesVertical = (int) Math.ceil(height / rectrangle_size);
final 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 * rectrangle_size;
r.left = j * rectrangle_size;
r.bottom = r.top + rectrangle_size;
r.right = r.left + rectrangle_size;
final Paint paint = new Paint();
paint.setColor(isWhite ? Color.WHITE : Color.GRAY);
canvas.drawRect(r, paint);
isWhite = !isWhite;
}
verticalStartWhite = !verticalStartWhite;
}
canvas.drawColor(color);
final Paint paint = new Paint();
paint.setColor(Color.WHITE);
paint.setStrokeWidth(2.0f);
final float[] points =
new float[] {
0, 0, width, 0, 0, 0, 0, height, width, 0, width, height, 0, height, width, height
};
canvas.drawLines(points, paint);
return bm;
}
public void draw(Canvas canvas, MapView mapView, boolean shadow) {
if (shadow == false) {
Projection projection = mapView.getProjection();
int length = pathGeoPoints.length;
projectedPoints = new float[length * 4]; // Make room for from.x, from.y, to.x, to.y
for (int g = 0, p = 1; g < length; g++, p += 2) {
pathPoints[g] = projection.toPixels(pathGeoPoints[g], null);
if (g % 2 != 0) {
projectedPoints[p] = pathPoints[g].y;
projectedPoints[p - 1] = pathPoints[g].x;
projectedPoints[p - 2] = pathPoints[g - 1].y;
projectedPoints[p - 3] = pathPoints[g - 1].x;
}
}
canvas.drawLines(projectedPoints, paint);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (mBytes == null) {
return;
}
if (mPoints == null || mPoints.length < mBytes.length * 4) {
mPoints = new float[mBytes.length * 4];
}
mRect.set(0, 0, getWidth(), getHeight());
for (int i = 0; i < mBytes.length - 1; i++) {
mPoints[i * 4] = mRect.width() * i / (mBytes.length - 1);
mPoints[i * 4 + 1] =
mRect.height() / 2 + ((byte) (mBytes[i] + 128)) * (mRect.height() / 2) / 128;
mPoints[i * 4 + 2] = mRect.width() * (i + 1) / (mBytes.length - 1);
mPoints[i * 4 + 3] =
mRect.height() / 2 + ((byte) (mBytes[i + 1] + 128)) * (mRect.height() / 2) / 128;
}
canvas.drawLines(mPoints, mForePaint);
}
@Override
public void draw(Canvas c) {
// TODO Auto-generated method stub
if (m_isCropping) {
float[] pts = new float[16];
pts[0] = m_leftTop.x;
pts[1] = m_leftTop.y;
pts[2] = m_rightTop.x;
pts[3] = m_rightTop.y;
pts[4] = m_rightTop.x;
pts[5] = m_rightTop.y;
pts[6] = m_rightBottom.x;
pts[7] = m_rightBottom.y;
pts[8] = m_rightBottom.x;
pts[9] = m_rightBottom.y;
pts[10] = m_leftBottom.x;
pts[11] = m_leftBottom.y;
pts[12] = m_leftBottom.x;
pts[13] = m_leftBottom.y;
pts[14] = m_leftTop.x;
pts[15] = m_leftTop.y;
m_paint.setColor(Color.argb(255, 255, 255, 0));
m_paint.setStyle(Paint.Style.STROKE);
m_paint.setStrokeWidth(2.0f);
m_paint.setAntiAlias(true);
c.drawLines(pts, m_paint);
float radius = 8;
c.drawCircle(m_leftTop.x, m_leftTop.y, radius, m_paint);
c.drawCircle(m_rightTop.x, m_rightTop.y, radius, m_paint);
c.drawCircle(m_rightBottom.x, m_rightBottom.y, radius, m_paint);
c.drawCircle(m_leftBottom.x, m_leftBottom.y, radius, m_paint);
return;
}
}
private void showBlocks(Canvas canvas) {
int timeWidth = mViewInfo.timeRect.width() * 2 / 3;
int timeHeight = Math.min(mViewInfo.timeRect.height() * 2 / 3, 50);
Rect timeR = new Rect();
timeR.left = mViewInfo.timeRect.left + (mViewInfo.timeRect.width() - timeWidth) / 2;
timeR.right = timeR.left + timeWidth;
timeR.top = mViewInfo.timeRect.top + (mViewInfo.timeRect.height() - timeHeight) / 2;
timeR.bottom = timeR.top + timeHeight;
canvas.drawRect(timeR, mBlackPaint);
timeR.right = timeR.left + (int) (timeR.width() * mGameState.getLeftTimePercent());
canvas.drawRect(timeR, mGreenPaint);
Block[][] blocks = mGameState.getBlocks();
int rows = blocks.length;
int cols = blocks[0].length;
int blockSize =
Math.min(mViewInfo.blockRect.width() / cols, mViewInfo.blockRect.height() / rows);
mViewInfo.blockHeight = mViewInfo.blockWidth = blockSize;
Log.d(
LOG_TAG,
"r "
+ rows
+ ", c "
+ cols
+ ", w "
+ mViewInfo.blockRect.width()
+ ", h "
+ mViewInfo.blockRect.height()
+ "block "
+ blockSize);
Rect src = new Rect(0, 0, ANIMAL_BITMAP_WIDTH, ANIMAL_BITMAP_HEIGHT);
Rect dst = new Rect();
for (int r = 0; r < rows; ++r) {
for (int c = 0; c < cols; ++c) {
if (blocks[r][c].isUnselected()) {
dst.set(0, 0, mViewInfo.blockWidth, mViewInfo.blockHeight);
dst.offset(
mViewInfo.blockRect.left + c * mViewInfo.blockWidth,
mViewInfo.blockRect.top + r * mViewInfo.blockHeight);
canvas.drawBitmap(mPictureInfo.animalBitmaps.get(blocks[r][c].imgIndex), src, dst, null);
} else if (blocks[r][c].isSelected()) {
dst.set(0, 0, mViewInfo.blockWidth, mViewInfo.blockHeight);
dst.offset(
mViewInfo.blockRect.left + c * mViewInfo.blockWidth,
mViewInfo.blockRect.top + r * mViewInfo.blockHeight);
canvas.drawBitmap(
mPictureInfo.animalBitmaps.get(blocks[r][c].imgIndex), src, dst, mSelectedImgPaint);
}
}
}
ArrayList<Point> linkPath = mGameState.getLinkPath();
if (linkPath != null) {
int lineCount = linkPath.size() - 1;
float[] points = new float[lineCount * 4];
for (int i = 0, j = 0; i < linkPath.size(); ++i, j += 2) {
int r = linkPath.get(i).row;
int c = linkPath.get(i).col;
if (c >= 0 && c < cols) {
points[j] = c * mViewInfo.blockWidth + mViewInfo.blockWidth / 2;
} else if (c == -1) {
points[j] = 0;
} else if (c == cols) {
points[j] = cols * mViewInfo.blockWidth;
}
points[j] += mViewInfo.blockRect.left;
if (r >= 0 && r < rows) {
points[j + 1] = r * mViewInfo.blockHeight + mViewInfo.blockHeight / 2;
} else if (r == -1) {
points[j + 1] = 0;
} else if (r == rows) {
points[j + 1] = rows * mViewInfo.blockHeight;
}
points[j + 1] += mViewInfo.blockRect.top;
if (i > 0 && i < linkPath.size() - 1) {
j += 2;
points[j] = points[j - 2];
points[j + 1] = points[j - 1];
}
}
canvas.drawLines(points, mLinePaint);
}
ArrayList<Point> hintPoints = mGameState.getHintPoints();
if (hintPoints != null) {
Log.d(
LOG_TAG,
"draw hintPath r1 "
+ hintPoints.get(0).row
+ ", c1 "
+ hintPoints.get(0).col
+ ", r2 "
+ hintPoints.get(1).row
+ ", c2 "
+ hintPoints.get(1).col);
for (int i = 0; i < 2; i++) {
int r = hintPoints.get(i).row;
int c = hintPoints.get(i).col;
dst.set(0, 0, mViewInfo.blockWidth, mViewInfo.blockHeight);
dst.offset(
mViewInfo.blockRect.left + c * mViewInfo.blockWidth,
mViewInfo.blockRect.top + r * mViewInfo.blockHeight);
canvas.drawRect(dst, mHintPaint);
}
}
}
public synchronized void DrawOnCanvas(
TReflectionWindowStruc RW, double VisibleFactor, Canvas canvas) {
double RW_SqrScale = Math.pow(RW.Scale(), 2);
// . calculate max item number depends on image square
int SquareOrderHintList_Size = 5 * 4;
// . prepare square ordered item list
TSpaceHintItem SquareOrderHintList = null;
TSpaceHint Item = Items;
while (Item != null) {
if (RW.Container_IsNodeVisible(Item.BindingPointX, Item.BindingPointY)) {
if ((Item.BaseSquare * RW_SqrScale) >= VisibleFactor) {
TXYCoord P = RW.ConvertToScreen(Item.BindingPointX, Item.BindingPointY);
if (((RW.Xmn <= P.X) && (P.X <= RW.Xmx)) && ((RW.Ymn <= P.Y) && (P.Y <= RW.Ymx))) {
int Size = SquareOrderHintList_Size;
TSpaceHintItem LastHintItem = null;
TSpaceHintItem HintItem = SquareOrderHintList;
while (HintItem != null) {
if (HintItem.Item.BaseSquare < Item.BaseSquare) break; // . >
// .
Size--;
if (Size <= 0) break; // . >
// .
LastHintItem = HintItem;
HintItem = HintItem.Next;
}
if (Size > 0)
if (LastHintItem != null)
LastHintItem.Next = new TSpaceHintItem(Item, LastHintItem.Next);
else SquareOrderHintList = new TSpaceHintItem(Item, SquareOrderHintList);
}
}
}
// .
Item = Item.Next;
}
// . re-order item list and prepare a draw list
TSpaceHint[] DrawItemList = new TSpaceHint[SquareOrderHintList_Size];
TSpaceHintItem HintItem = SquareOrderHintList;
for (int I = SquareOrderHintList_Size - 1; I >= 0; I--)
if (HintItem != null) {
DrawItemList[I] = HintItem.Item;
HintItem = HintItem.Next;
} else break; // . >
// . draw list
for (int I = 0; I < DrawItemList.length; I++) {
Item = DrawItemList[I];
if (Item != null) {
TXYCoord P = RW.ConvertToScreen(Item.BindingPointX, Item.BindingPointY);
// . draw image
float Left = (float) P.X;
boolean flImage = false;
synchronized (ItemsImageDataFiles) {
TSpaceHintImageDataFile ImageDataFile =
ItemsImageDataFiles.ItemsTable.get(Item.InfoImageDATAFileID);
if ((ImageDataFile != null) && (ImageDataFile.Data != null)) {
RectF ImageRect = ImageDataFile.Data_GetDestinationRect(ItemImageMinSize);
ImageRect.offset(Left, (float) (P.Y - ImageRect.height()));
// .
canvas.drawBitmap(
ImageDataFile.Data,
ImageDataFile.Data_GetOriginalRect(),
ImageRect,
DrawPointItemImagePaint);
// .
Left += ImageRect.width() + 1.0F;
flImage = true;
}
}
// . draw selection if it exists
if (Item.flSelected) {
Rect TR = new Rect();
Item.paint.getTextBounds(Item.InfoString, 0, Item.InfoString.length(), TR);
float X0, Y0, X1, Y1;
X0 = Left - ItemSpacing;
Y0 = (float) P.Y - (TR.bottom - TR.top) - ItemSpacing;
X1 = Left + (TR.right - TR.left) + ItemSpacing;
Y1 = (float) P.Y + ItemSpacing;
// .
SelectedPaint.setColor(Color.argb(127, 255, 0, 0));
canvas.drawRect(X0, Y0, X1, Y1, SelectedPaint);
float[] Points = {X0, Y0, X1, Y0, X1, Y0, X1, Y1, X1, Y1, X0, Y1, X0, Y1, X0, Y0};
SelectedPaint.setColor(Color.argb(255, 255, 0, 0));
canvas.drawLines(Points, SelectedPaint);
}
// . draw image
if (!flImage) canvas.drawCircle((float) P.X, (float) P.Y, 3.0F, DrawPointPaint);
// . draw text
Paint ShadowPaint = new Paint(Item.paint);
ShadowPaint.setColor(Color.BLACK);
canvas.drawText(Item.InfoString, Left + 1, (float) P.Y + 1, ShadowPaint);
canvas.drawText(Item.InfoString, Left, (float) P.Y, Item.paint);
}
}
}
protected void drawDataSet(Canvas c, CandleDataSet dataSet) {
Transformer trans = mChart.getTransformer(dataSet.getAxisDependency());
float phaseX = mAnimator.getPhaseX();
float phaseY = mAnimator.getPhaseY();
int dataSetIndex = mChart.getCandleData().getIndexOfDataSet(dataSet);
List<CandleEntry> entries = dataSet.getYVals();
Entry entryFrom = dataSet.getEntryForXIndex(mMinX);
Entry entryTo = dataSet.getEntryForXIndex(mMaxX);
int minx = Math.max(dataSet.getEntryPosition(entryFrom), 0);
int maxx = Math.min(dataSet.getEntryPosition(entryTo) + 1, entries.size());
int range = (maxx - minx) * 4;
int to = (int) Math.ceil((maxx - minx) * phaseX + minx);
CandleShadowBuffer shadowBuffer = mShadowBuffers[dataSetIndex];
shadowBuffer.setPhases(phaseX, phaseY);
shadowBuffer.limitFrom(minx);
shadowBuffer.limitTo(maxx);
shadowBuffer.feed(entries);
trans.pointValuesToPixel(shadowBuffer.buffer);
mRenderPaint.setStyle(Paint.Style.STROKE);
// If not set, use default functionality for backward compatibility
if (dataSet.getShadowColor() == ColorTemplate.COLOR_NONE) {
mRenderPaint.setColor(dataSet.getColor());
} else {
mRenderPaint.setColor(dataSet.getShadowColor());
}
mRenderPaint.setStrokeWidth(dataSet.getShadowWidth());
// draw the shadow
c.drawLines(shadowBuffer.buffer, 0, range, mRenderPaint);
CandleBodyBuffer bodyBuffer = mBodyBuffers[dataSetIndex];
bodyBuffer.setBodySpace(dataSet.getBodySpace());
bodyBuffer.setPhases(phaseX, phaseY);
bodyBuffer.limitFrom(minx);
bodyBuffer.limitTo(maxx);
bodyBuffer.feed(entries);
trans.pointValuesToPixel(bodyBuffer.buffer);
// draw the body
for (int j = 0; j < range; j += 4) {
// get the entry
CandleEntry e = entries.get(j / 4 + minx);
if (!fitsBounds(e.getXIndex(), mMinX, to)) continue;
float leftBody = bodyBuffer.buffer[j];
float open = bodyBuffer.buffer[j + 1];
float rightBody = bodyBuffer.buffer[j + 2];
float close = bodyBuffer.buffer[j + 3];
// draw body differently for increasing and decreasing entry
if (open > close) { // decreasing
if (dataSet.getDecreasingColor() == ColorTemplate.COLOR_NONE) {
mRenderPaint.setColor(dataSet.getColor(j / 4 + minx));
} else {
mRenderPaint.setColor(dataSet.getDecreasingColor());
}
mRenderPaint.setStyle(dataSet.getDecreasingPaintStyle());
// draw the body
c.drawRect(leftBody, close, rightBody, open, mRenderPaint);
} else if (open < close) {
if (dataSet.getIncreasingColor() == ColorTemplate.COLOR_NONE) {
mRenderPaint.setColor(dataSet.getColor(j / 4 + minx));
} else {
mRenderPaint.setColor(dataSet.getIncreasingColor());
}
mRenderPaint.setStyle(dataSet.getIncreasingPaintStyle());
// draw the body
c.drawRect(leftBody, open, rightBody, close, mRenderPaint);
} else { // equal values
mRenderPaint.setColor(Color.BLACK);
mRenderPaint.setStyle(Paint.Style.STROKE);
c.drawLine(leftBody, open, rightBody, close, mRenderPaint);
}
}
}
/**
* 自定义的方法,简单绘制一些基本图形
*
* @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);
}
@Override
public void draw(Canvas canvas, Paint paint) {
canvas.drawLines(
new float[] {(float) corner1, (float) corner2, (float) corner3, (float) corner1}, paint);
}
