/**
* Creates an animator that can be used for x and/or y translations. When interrupted, it sets a
* tag to keep track of the position so that it may be continued from position.
*
* @param view The view being moved. This may be in the overlay for onDisappear.
* @param values The values containing the view in the view hierarchy.
* @param viewPosX The x screen coordinate of view
* @param startX The start translation x of view
* @param endX The end translation x of view
* @param interpolator The interpolator to use with this animator.
* @return An animator that moves from (startX, startY) to (endX, endY) unless there was a
* previous interruption, in which case it moves from the current position to (endX, endY).
*/
static Animator createAnimation(
View view,
TransitionValues values,
int viewPosX,
float startX,
float endX,
TimeInterpolator interpolator,
Transition transition) {
float terminalX = view.getTranslationX();
Integer startPosition = (Integer) values.view.getTag(R.id.transitionPosition);
if (startPosition != null) {
startX = startPosition - viewPosX + terminalX;
}
// Initial position is at translation startX, startY, so position is offset by that
// amount
int startPosX = viewPosX + Math.round(startX - terminalX);
view.setTranslationX(startX);
if (startX == endX) {
return null;
}
Path path = new Path();
path.moveTo(startX, 0);
path.lineTo(endX, 0);
ObjectAnimator anim =
ObjectAnimator.ofFloat(view, View.TRANSLATION_X, View.TRANSLATION_Y, path);
TransitionPositionListener listener =
new TransitionPositionListener(view, values.view, startPosX, terminalX);
transition.addListener(listener);
anim.addListener(listener);
anim.addPauseListener(listener);
anim.setInterpolator(interpolator);
return anim;
}
private static Path createCubic(
float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4) {
Path localPath = new Path();
localPath.moveTo(0.0F, 0.0F);
localPath.cubicTo(paramFloat1, paramFloat2, paramFloat3, paramFloat4, 1.0F, 1.0F);
return localPath;
}
private void computePath(Rect bounds) {
final float currentScale = mCurrentScale;
final Path path = mPath;
final RectF rect = mRect;
final Matrix matrix = mMatrix;
path.reset();
int totalSize = Math.min(bounds.width(), bounds.height());
float initial = mClosedStateSize;
float destination = totalSize;
float currentSize = initial + (destination - initial) * currentScale;
float halfSize = currentSize / 2f;
float inverseScale = 1f - currentScale;
float cornerSize = halfSize * inverseScale;
float[] corners =
new float[] {
halfSize, halfSize, halfSize, halfSize, halfSize, halfSize, cornerSize, cornerSize
};
rect.set(bounds.left, bounds.top, bounds.left + currentSize, bounds.top + currentSize);
path.addRoundRect(rect, corners, Path.Direction.CCW);
matrix.reset();
matrix.postRotate(-45, bounds.left + halfSize, bounds.top + halfSize);
matrix.postTranslate((bounds.width() - currentSize) / 2, 0);
float hDiff = (bounds.bottom - currentSize - mExternalOffset) * inverseScale;
matrix.postTranslate(0, hDiff);
path.transform(matrix);
}
private void drawIntoBitmap() {
Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
if (mAlpha) {
if (!mBlur) {
mViewBitmap.eraseColor(Color.TRANSPARENT);
}
}
if (mBlur) {
if (mAlphaMark) {
p.setAlpha(mBlurVal);
} else {
mAlphaMark = true;
}
}
Canvas c = new Canvas(mViewBitmap);
c.save();
Path path = new Path();
path.moveTo(0, 0);
path.arcTo(
new RectF(-mBitmapViewWidth, -mBitmapViewWidth, mBitmapViewWidth, mBitmapViewWidth),
0,
mAngle);
// path.lineTo(0, 1);
path.close();
c.clipPath(path);
// c.drawRGB(0, 0, 0);
// RectF r = new RectF(0, 0, mBitmapViewWidth, mBitmapViewHeight);
c.drawBitmap(
mBitmap,
new Rect(mCurX, mCurY, mRadius + mCurX, mBitmapNewHeight + mCurY),
new RectF(0, 0, mBitmapViewWidth, mBitmapViewHeight),
p);
}
public DrawView(Context context) {
super(context);
rect = new Rect(0, 0, 100, 100);
rect1 = new Rect(0, 0, 500, 200);
p = new Paint(Paint.ANTI_ALIAS_FLAG);
picture = new Picture();
Canvas canvas = picture.beginRecording(300, 300);
p.setColor(Color.GREEN);
canvas.drawCircle(150, 100, 80, p);
p.setColor(Color.BLUE);
canvas.drawRect(20, 70, 150, 200, p);
p.setColor(Color.RED);
path = new Path();
path.moveTo(170, 80);
path.lineTo(240, 210);
path.lineTo(100, 210);
path.close();
canvas.drawPath(path, p);
picture.endRecording();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
// TODO Auto-generated method stub
int action = event.getAction();
int x = (int) event.getX();
int y = (int) event.getY();
switch (action) {
case MotionEvent.ACTION_DOWN:
mLastX = x;
mLastY = y;
mPath.moveTo(mLastX, mLastY);
break;
case MotionEvent.ACTION_MOVE:
int dx = Math.abs(x - mLastX);
int dy = Math.abs(y - mLastY);
if (dx > 3 || dy > 3) {
mPath.lineTo(x, y);
}
mLastX = x;
mLastY = y;
break;
case MotionEvent.ACTION_UP:
new Thread(mRunnable).start();
break;
default:
break;
}
invalidate();
return true;
}
Bitmap getSmile() {
float x1, y1, x3, y3;
x1 = 200;
y1 = 300;
x3 = 250;
y3 = 300;
Paint paint =
new Paint() {
{
setStyle(Paint.Style.STROKE);
setStrokeCap(Paint.Cap.ROUND);
setStrokeWidth(3.0f);
setAntiAlias(true);
}
};
final Path path = new Path();
path.moveTo(x1, 290);
final float x2 = (x3 + x1) / 2;
final float y2 = (y3 + y1) / 2;
path.cubicTo(x1, y1, x2, y2, x3, y3);
Bitmap bg = Bitmap.createBitmap(480, 800, Bitmap.Config.ARGB_8888);
Canvas canvas_smile = new Canvas(bg);
canvas_smile.drawPath(path, paint);
return bg;
}
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);
}
}
}
private Path getArcPath() {
Path path = new Path();
path.addArc(rectF, startAngle, 90);
path.addArc(rectF, startAngle + 90 + 30, 90);
path.addArc(rectF, startAngle + 90 + 90 + 30 + 30, 90);
return path;
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
centerX = w / 2;
centerY = h / 2;
// Make reference line long enough to cross the bounds diagonally after being rotated.
referenceLine.reset();
float radius = (float) Math.hypot(centerX, centerY);
float delta = radius - centerX;
referenceLine.moveTo(-delta, centerY);
referenceLine.lineTo(getWidth() + delta, centerY);
delta = radius - centerY;
referenceLine.moveTo(centerX, -delta);
referenceLine.lineTo(centerX, getHeight() + delta);
// Set grids inside photo display bounds.
grids.reset();
delta = displayBounds.width() / 4.0f;
for (float x = displayBounds.left + delta; x < displayBounds.right; x += delta) {
grids.moveTo(x, displayBounds.top);
grids.lineTo(x, displayBounds.bottom);
}
delta = displayBounds.height() / 4.0f;
for (float y = displayBounds.top + delta; y < displayBounds.bottom; y += delta) {
grids.moveTo(displayBounds.left, y);
grids.lineTo(displayBounds.right, y);
}
}
@Override
public boolean onTouch(View v, MotionEvent event) {
Path temp = new Path();
float rx = event.getX();
float ry = event.getY();
mNodes =
mGraph.getShortestPath(
fromSpin.getSelectedItem().toString(), toSpin.getSelectedItem().toString());
// temp.rMoveTo(rx, ry);
float x, y;
String res = " ";
for (int i = 0; i < mNodes.size(); i++) {
x = (float) mNodes.get(i).getX();
y = (float) mNodes.get(i).getY();
res += mNodes.get(i).getLabel() + " ";
if (i != 0) {
temp.lineTo(x, y);
}
temp.moveTo(x, y);
}
Log.d("Path", res);
myMap.setMap(temp, 2, rx, ry);
return true;
}
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;
}
}
}
public boolean onTouch(View view, MotionEvent event) {
float x = event.getX();
float y = event.getY();
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
path.moveTo(x, y);
return true;
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_MOVE:
l = x;
r = x;
t = y;
b = y;
for (int i = 0; i < event.getHistorySize(); i++) {
float newX = event.getHistoricalX(i);
float newY = event.getHistoricalY(i);
path.lineTo(newX, newY);
l = newX < l ? newX : l;
t = newY < t ? newY : t;
r = newX > r ? newX : r;
b = newY > b ? newY : b;
}
rect.set(l, t, r, b);
Log.d("TAG", rect.toShortString());
invalidate(
(int) rect.left - 5, (int) rect.top - 5, (int) rect.right + 5, (int) rect.bottom + 5);
break;
default:
}
return super.onTouchEvent(event);
}
/**
* 绘制图网络线
*
* @param canvas 画布
* @param lineData 数据集类
* @param arrayDataX x坐标
* @param arrayDataY y坐标
*/
private void drawDataPath(
Canvas canvas, RadarData lineData, Float[] arrayDataX, Float[] arrayDataY) {
float startX = 0.0f, startY = 0.0f;
float initX = 0.0f, initY = 0.0f;
Path pathArea = new Path();
for (int p = 0; p < arrayDataX.length; p++) {
if (0 == p) {
initX = startX = arrayDataX[p];
initY = startY = arrayDataY[p];
pathArea.moveTo(initX, initY);
} else {
pathArea.lineTo(arrayDataX[p], arrayDataY[p]);
startX = arrayDataX[p];
startY = arrayDataY[p];
}
// 绘制点及对应的标签
renderDotAndLabel(canvas, lineData, arrayDataX[p], arrayDataY[p], p);
}
// 收尾
pathArea.lineTo(initX, initY);
pathArea.close();
lineData.getPlotLine().getLinePaint().setAlpha(mAreaAlpha);
// lineData.getPlotLine().getLinePaint().setStyle(Style.STROKE);
canvas.drawPath(pathArea, lineData.getPlotLine().getLinePaint());
}
public void touch_start(float x, float y) {
mPath.reset();
mPath.moveTo(x, y);
mX = x;
mY = y;
invalidate();
}
/** 绘制焦点框 */
@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 drawPointerArrow(Canvas canvas) {
int centerX = getWidth() / 2;
int centerY = getHeight() / 2;
double tipAngle = (colorHSV[2] - 0.5f) * Math.PI;
double leftAngle = tipAngle + Math.PI / 96;
double rightAngle = tipAngle - Math.PI / 96;
double tipAngleX = Math.cos(tipAngle) * outerWheelRadius;
double tipAngleY = Math.sin(tipAngle) * outerWheelRadius;
double leftAngleX = Math.cos(leftAngle) * (outerWheelRadius + arrowPointerSize);
double leftAngleY = Math.sin(leftAngle) * (outerWheelRadius + arrowPointerSize);
double rightAngleX = Math.cos(rightAngle) * (outerWheelRadius + arrowPointerSize);
double rightAngleY = Math.sin(rightAngle) * (outerWheelRadius + arrowPointerSize);
arrowPointerPath.reset();
arrowPointerPath.moveTo((float) tipAngleX + centerX, (float) tipAngleY + centerY);
arrowPointerPath.lineTo((float) leftAngleX + centerX, (float) leftAngleY + centerY);
arrowPointerPath.lineTo((float) rightAngleX + centerX, (float) rightAngleY + centerY);
arrowPointerPath.lineTo((float) tipAngleX + centerX, (float) tipAngleY + centerY);
valuePointerArrowPaint.setColor(Color.HSVToColor(colorHSV));
valuePointerArrowPaint.setStyle(Style.FILL);
canvas.drawPath(arrowPointerPath, valuePointerArrowPaint);
valuePointerArrowPaint.setStyle(Style.STROKE);
valuePointerArrowPaint.setStrokeJoin(Join.ROUND);
valuePointerArrowPaint.setColor(Color.BLACK);
canvas.drawPath(arrowPointerPath, valuePointerArrowPaint);
}
@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow) {
super.draw(canvas, mapView, shadow);
if (shadow) {
return;
}
Projection projection = mapView.getProjection();
Path path = new Path();
boolean isFirst = true;
for (int i = 0; i < pointsSize; i++) {
GeoPoint gPoint = points.get(i);
Point pixelPoint = pixelPoints[i];
projection.toPixels(gPoint, pixelPoint);
if (isFirst) {
path.moveTo(pixelPoint.x, pixelPoint.y);
isFirst = false;
} else {
path.lineTo(pixelPoint.x, pixelPoint.y);
}
}
canvas.drawPath(path, mPaint);
}
private void touchUp() {
mPath.lineTo(mX, mY);
// commit the path to our offscreen
mCanvas.drawPath(mPath, mPaint);
// kill this so we don't double draw
mPath.reset();
}
MyPath(float x, float y, int size, int color) {
super(color);
path = new Path();
this.size = size;
path.moveTo(x, y);
path.lineTo(x, y);
}
@Override
public void draw(Canvas canvas, MapView mapView, boolean shadow) {
if (!this.visible) return;
// long start = System.currentTimeMillis();
Projection projection = mapView.getProjection();
Path p = new Path();
Paint polygonPaint = new Paint();
polygonPaint.setStrokeWidth(this.style.width);
polygonPaint.setColor(this.style.color);
polygonPaint.setStyle(Paint.Style.STROKE);
polygonPaint.setAntiAlias(true);
for (int i = 0; i < path.size(); i++) {
if (i == path.size() - 1) {
break;
}
Point from = new Point();
Point to = new Point();
projection.toPixels(path.get(i), from);
projection.toPixels(path.get(i + 1), to);
if (i == 0) {
p.moveTo(from.x, from.y);
}
p.lineTo(to.x, to.y);
}
canvas.drawPath(p, polygonPaint);
// Log.d("Tracker", "Path drawing complete in " + String.valueOf(System.currentTimeMillis() -
// start) + "ms");
}
/*
* Drawing
*/
@Override
public void draw(Canvas canvas) {
final boolean positionChanged = adapterPositionChanged();
if (rippleOverlay) {
if (!positionChanged) {
rippleBackground.draw(canvas);
}
super.draw(canvas);
if (!positionChanged) {
if (rippleRoundedCorners != 0) {
Path clipPath = new Path();
RectF rect = new RectF(0, 0, canvas.getWidth(), canvas.getHeight());
clipPath.addRoundRect(
rect, rippleRoundedCorners, rippleRoundedCorners, Path.Direction.CW);
canvas.clipPath(clipPath);
}
canvas.drawCircle(currentCoords.x, currentCoords.y, radius, paint);
}
} else {
if (!positionChanged) {
rippleBackground.draw(canvas);
canvas.drawCircle(currentCoords.x, currentCoords.y, radius, paint);
}
super.draw(canvas);
}
}
@Override
protected void dispatchDraw(Canvas canvas) {
if (mShowcaseX < 0 || mShowcaseY < 0 || mIsRedundant) {
super.dispatchDraw(canvas);
return;
}
boolean recalculatedCling = mShowcaseDrawer.calculateShowcaseRect(mShowcaseX, mShowcaseY);
boolean recalculateText = recalculatedCling || mAlteredText;
mAlteredText = false;
if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.HONEYCOMB && !mHasNoTarget) {
Path path = new Path();
path.addCircle(mShowcaseX, mShowcaseY, mShowcaseRadius, Path.Direction.CW);
canvas.clipPath(path, Op.DIFFERENCE);
}
// Draw background color
canvas.drawColor(mBackgroundColor);
// Draw the showcase drawable
if (!mHasNoTarget) {
mShowcaseDrawer.drawShowcase(
canvas, mShowcaseX, mShowcaseY, mScaleMultiplier, mShowcaseRadius);
}
// Draw the text on the screen, recalculating its position if necessary
if (recalculateText) {
mTextDrawer.calculateTextPosition(canvas.getWidth(), canvas.getHeight(), this);
}
mTextDrawer.draw(canvas, recalculateText);
super.dispatchDraw(canvas);
}
@Override
public Path computePath(int radius, int l, int t, int r, int b) {
final Point o = computeOrigin(l, t, r, b);
final Path path = new Path();
path.addCircle(o.x, o.y, radius, Path.Direction.CW);
return path;
}
// ==============================================================================
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;
}
private static Path createLightPath(int width, int height) {
final Path path = new Path();
path.moveTo(0, height);
path.lineTo(0, 0);
path.lineTo(width, 0);
return path;
}
private void drawIntoBitmap(int i) {
Canvas c = new Canvas(mViewBitmap);
// Paint p = new Paint();
Paint p = new Paint(Paint.ANTI_ALIAS_FLAG);
if (mBlur) {
if (mAlphaMark) {
p.setAlpha(mBlurVal);
} else {
mAlphaMark = true;
}
}
// p.setAntiAlias(true);
c.save();
Path path = new Path();
path.moveTo(0, 0);
path.arcTo(
new RectF(-mBitmapViewWidth, -mBitmapViewWidth, mBitmapViewWidth, mBitmapViewWidth),
0,
mAngle);
// path.lineTo(0, 1);
path.close();
c.clipPath(path);
// RectF r = new RectF(0, 0, mBitmapViewWidth, mBitmapViewHeight);
c.drawBitmap(
mBitmap,
new Rect(mCurX, mCurY, mRadius + mCurX, mBitmapNewHeight + mCurY),
new RectF(0, 0, mBitmapViewWidth, mBitmapViewHeight),
p);
// mPaint.setTextSize(28);
// mPaint.setColor(Color.RED);
// c.drawText(debugString, 150, 50, mPaint);
}
public void paintBitmap(Context context, Canvas c, Rect dest) {
int color0 = Color.argb(0xFF, 196, 181, 51);
int color1 = Color.argb(0xFF, 251, 219, 39);
int color2 = Color.argb(0xFF, 255, 239, 151);
int border = Color.argb(0xFF, 220, 200, 80);
Paint p = new Paint();
p.setAntiAlias(true);
float width = dest.width() / 20.0f;
float insideSize = dest.width() - 2 * width;
RectF inside1 =
new RectF(
dest.left + width - 1,
dest.top + width - 1,
dest.right - width + 1,
dest.bottom - width + 1);
RectF inside =
new RectF(dest.left + width, dest.top + width, dest.right - width, dest.bottom - width);
LinearGradient linear =
new LinearGradient(
inside1.left,
inside1.top + insideSize / 3,
inside1.right,
inside1.top + 2 * insideSize / 3,
new int[] {color0, color1, color2},
null,
Shader.TileMode.CLAMP);
p.setShader(linear);
c.drawRoundRect(inside1, width, width, p);
p.setShader(null);
p.setColor(border);
Path path = new Path();
path.addRoundRect(inside, width, width, Path.Direction.CCW);
path.addRect(new RectF(dest), Path.Direction.CW);
c.drawPath(path, p);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
float touchX = event.getX();
float touchY = event.getY();
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
drawPath.moveTo(touchX, touchY);
break;
case MotionEvent.ACTION_MOVE:
drawPath.lineTo(touchX, touchY);
break;
case MotionEvent.ACTION_UP:
drawCanvas.drawPath(drawPath, drawPaint);
drawPath.reset();
break;
default:
return false;
}
// send the X & Y coordinates over bluetooth.
sendPointToBluetooth(touchX, touchY);
postInvalidate(); // Indicate view should be redrawn
return true; // Indicate we've consumed the touch
// detect user touch
}
public void onDraw(Canvas canvas, int measuredWidth, int measuredHeight) {
if (!visual || text == null) {
return;
}
float actualDistance = distance + height / 2;
calcOffset(actualDistance, measuredWidth, measuredHeight);
rectPaint.setColor(backgroundColor);
if (alpha != 0) {
rectPaint.setAlpha(alpha);
}
rectPaint.setStrokeWidth(height);
rectPath.reset();
rectPath.moveTo(startPosX, startPosY);
rectPath.lineTo(endPosX, endPosY);
canvas.drawPath(rectPath, rectPaint);
textPaint.setTextSize(textSize);
textPaint.setColor(textColor);
textPaint.getTextBounds(text, 0, text.length(), textBound);
canvas.drawTextOnPath(
text,
rectPath,
(1.4142135f * actualDistance) / 2 - textBound.width() / 2,
textBound.height() / 2,
textPaint);
}
