/**
* Drawing src bitmap to dest bitmap with rounded corners
*
* @param src source bitmap
* @param dest destination bitmap
* @param radius radius in destination bitmap scale
* @param clearColor clear color
*/
public static void drawRoundedCorners(Bitmap src, Bitmap dest, int radius, int clearColor) {
clearBitmap(dest, clearColor);
Canvas canvas = new Canvas(dest);
Rect sourceRect = WorkCache.RECT1.get();
Rect destRect = WorkCache.RECT2.get();
sourceRect.set(0, 0, src.getWidth(), src.getHeight());
destRect.set(0, 0, dest.getWidth(), dest.getHeight());
RectF roundRect = WorkCache.RECTF1.get();
roundRect.set(0, 0, dest.getWidth(), dest.getHeight());
Paint paint = WorkCache.PAINT.get();
paint.reset();
paint.setStyle(Paint.Style.FILL);
paint.setColor(Color.RED);
paint.setAntiAlias(true);
canvas.drawRoundRect(roundRect, radius, radius, paint);
paint.reset();
paint.setFilterBitmap(true);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawBitmap(src, sourceRect, destRect, paint);
canvas.setBitmap(null);
}
protected void drawRect(Canvas canvas, RectF dims, Paint paint) {
switch (borderStyle) {
case ROUNDED:
canvas.drawRoundRect(dims, borderRadiusX, borderRadiusY, paint);
break;
case SQUARE:
canvas.drawRect(dims, paint);
break;
default:
}
}
private void drawBorder(Canvas canvas) {
RectF rect = new RectF(getBounds());
rect.inset(borderThickness / 2, borderThickness / 2);
if (shape instanceof OvalShape) {
canvas.drawOval(rect, borderPaint);
} else if (shape instanceof RoundRectShape) {
canvas.drawRoundRect(rect, radius, radius, borderPaint);
} else {
canvas.drawRect(rect, borderPaint);
}
}
public void doDraw(Canvas cs) {
super.doDraw(cs);
this.drawSimpleShadow(cs, 6);
// draw background
mBackground.setColor(style.iBackgroundColor);
cs.drawRoundRect(rtBackground, style.fBackgroundRound, style.fBackgroundRound, mBackground);
final float fTextModeTop = rtBounds.top + rtTextMode.height() + iTopMargin;
// draw Mode Value
cs.drawText(sModeValue, rtBarFrame.left, fTextModeTop, mTextModeValue);
}
/**
* 转换图片成圆形
*
* @param bitmap 传入Bitmap对象
* @return
*/
public Bitmap toRoundBitmap(Bitmap bitmap) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
float roundPx;
float left, top, right, bottom, dst_left, dst_top, dst_right, dst_bottom;
if (width <= height) {
roundPx = width / 2;
top = 0;
bottom = width;
left = 0;
right = width;
height = width;
dst_left = 0;
dst_top = 0;
dst_right = width;
dst_bottom = width;
} else {
roundPx = height / 2;
float clip = (width - height) / 2;
left = clip;
right = width - clip;
top = 0;
bottom = height;
width = height;
dst_left = 0;
dst_top = 0;
dst_right = height;
dst_bottom = height;
}
Bitmap output = Bitmap.createBitmap(width, height, Config.ARGB_8888);
Canvas canvas = new Canvas(output);
final int color = 0xff424242;
final Paint paint = new Paint();
final Rect src = new Rect((int) left, (int) top, (int) right, (int) bottom);
final Rect dst = new Rect((int) dst_left, (int) dst_top, (int) dst_right, (int) dst_bottom);
final RectF rectF = new RectF(dst);
paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(color);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, src, dst, paint);
return output;
}
public static Bitmap roundedCornerBitmap(Bitmap bitmap, float radis) {
Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888);
Canvas canvas = new Canvas(output);
// final int color = 0xff424242;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
final RectF rectF = new RectF(rect);
final float roundPx = radis;
paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(Color.WHITE);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);
return output;
}
public static Bitmap makeBitmapCircle(Bitmap bitmap) {
Bitmap output =
Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(output);
final int color = 0xff000000;
final Paint paint = new Paint();
final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
final RectF rectF = new RectF(rect);
final float roundPx = bitmap.getWidth() / 2;
paint.setAntiAlias(true);
canvas.drawARGB(0, 0, 0, 0);
paint.setColor(color);
canvas.drawRoundRect(rectF, roundPx, roundPx, paint);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawBitmap(bitmap, rect, rect, paint);
return output;
}
@Override
public void startElement(String namespaceURI, String localName, String qName, Attributes atts)
throws SAXException {
// Reset paint opacity
paint.setAlpha(255);
// Ignore everything but rectangles in bounds mode
if (boundsMode) {
if (localName.equals("rect")) {
Float x = getFloatAttr("x", atts);
if (x == null) {
x = 0f;
}
Float y = getFloatAttr("y", atts);
if (y == null) {
y = 0f;
}
Float width = getFloatAttr("width", atts);
Float height = getFloatAttr("height", atts);
bounds = new RectF(x, y, x + width, y + height);
}
return;
}
if (localName.equals("svg")) {
int width = (int) Math.ceil(getFloatAttr("width", atts));
int height = (int) Math.ceil(getFloatAttr("height", atts));
canvas = picture.beginRecording(width, height);
} else if (localName.equals("defs")) {
// Ignore
} else if (localName.equals("linearGradient")) {
gradient = doGradient(true, atts);
} else if (localName.equals("radialGradient")) {
gradient = doGradient(false, atts);
} else if (localName.equals("stop")) {
if (gradient != null) {
float offset = getFloatAttr("offset", atts);
String styles = getStringAttr("style", atts);
StyleSet styleSet = new StyleSet(styles);
String colorStyle = styleSet.getStyle("stop-color");
int color = Color.BLACK;
if (colorStyle != null) {
if (colorStyle.startsWith("#")) {
color = Integer.parseInt(colorStyle.substring(1), 16);
} else {
color = Integer.parseInt(colorStyle, 16);
}
}
String opacityStyle = styleSet.getStyle("stop-opacity");
if (opacityStyle != null) {
float alpha = Float.parseFloat(opacityStyle);
int alphaInt = Math.round(255 * alpha);
color |= (alphaInt << 24);
} else {
color |= 0xFF000000;
}
gradient.positions.add(offset);
gradient.colors.add(color);
}
} else if (localName.equals("g")) {
// Check to see if this is the "bounds" layer
if ("bounds".equalsIgnoreCase(getStringAttr("id", atts))) {
boundsMode = true;
}
if (hidden) {
hiddenLevel++;
// Util.debug("Hidden up: " + hiddenLevel);
}
// Go in to hidden mode if display is "none"
if ("none".equals(getStringAttr("display", atts))) {
if (!hidden) {
hidden = true;
hiddenLevel = 1;
// Util.debug("Hidden up: " + hiddenLevel);
}
}
pushTransform(atts);
} else if (!hidden && localName.equals("rect")) {
Float x = getFloatAttr("x", atts);
if (x == null) {
x = 0f;
}
Float y = getFloatAttr("y", atts);
if (y == null) {
y = 0f;
}
Float width = getFloatAttr("width", atts);
Float height = getFloatAttr("height", atts);
Float rx = getFloatAttr("rx", atts);
Float ry = getFloatAttr("ry", atts);
if (rx == null) {
if (ry == null) rx = ry = 0f;
else rx = ry;
} else {
if (ry == null) ry = rx;
}
if (rx > width / 2) rx = width * 0.5f;
if (ry > height / 2) ry = height * 0.5f;
pushTransform(atts);
Properties props = new Properties(atts);
if (doFill(props, gradientMap)) {
doLimits(x, y, width, height);
if (rx > 0 && ry > 0)
canvas.drawRoundRect(new RectF(x, y, x + width, y + height), rx, ry, paint);
else canvas.drawRect(x, y, x + width, y + height, paint);
}
if (doStroke(props, gradientMap)) {
if (rx > 0 && ry > 0)
canvas.drawRoundRect(new RectF(x, y, x + width, y + height), rx, ry, paint);
else canvas.drawRect(x, y, x + width, y + height, paint);
}
popTransform();
} else if (!hidden && localName.equals("line")) {
Float x1 = getFloatAttr("x1", atts);
Float x2 = getFloatAttr("x2", atts);
Float y1 = getFloatAttr("y1", atts);
Float y2 = getFloatAttr("y2", atts);
Properties props = new Properties(atts);
if (doStroke(props, gradientMap)) {
pushTransform(atts);
doLimits(x1, y1);
doLimits(x2, y2);
canvas.drawLine(x1, y1, x2, y2, paint);
popTransform();
}
} else if (!hidden && localName.equals("circle")) {
Float centerX = getFloatAttr("cx", atts);
Float centerY = getFloatAttr("cy", atts);
Float radius = getFloatAttr("r", atts);
if (centerX != null && centerY != null && radius != null) {
pushTransform(atts);
Properties props = new Properties(atts);
if (doFill(props, gradientMap)) {
doLimits(centerX - radius, centerY - radius);
doLimits(centerX + radius, centerY + radius);
canvas.drawCircle(centerX, centerY, radius, paint);
}
if (doStroke(props, gradientMap)) {
canvas.drawCircle(centerX, centerY, radius, paint);
}
popTransform();
}
} else if (!hidden && localName.equals("ellipse")) {
Float centerX = getFloatAttr("cx", atts);
Float centerY = getFloatAttr("cy", atts);
Float radiusX = getFloatAttr("rx", atts);
Float radiusY = getFloatAttr("ry", atts);
if (centerX != null && centerY != null && radiusX != null && radiusY != null) {
pushTransform(atts);
Properties props = new Properties(atts);
rect.set(centerX - radiusX, centerY - radiusY, centerX + radiusX, centerY + radiusY);
if (doFill(props, gradientMap)) {
doLimits(centerX - radiusX, centerY - radiusY);
doLimits(centerX + radiusX, centerY + radiusY);
canvas.drawOval(rect, paint);
}
if (doStroke(props, gradientMap)) {
canvas.drawOval(rect, paint);
}
popTransform();
}
} else if (!hidden && (localName.equals("polygon") || localName.equals("polyline"))) {
NumberParse numbers = getNumberParseAttr("points", atts);
if (numbers != null) {
Path p = new Path();
ArrayList<Float> points = numbers.numbers;
if (points.size() > 1) {
pushTransform(atts);
Properties props = new Properties(atts);
p.moveTo(points.get(0), points.get(1));
for (int i = 2; i < points.size(); i += 2) {
float x = points.get(i);
float y = points.get(i + 1);
p.lineTo(x, y);
}
// Don't close a polyline
if (localName.equals("polygon")) {
p.close();
}
if (doFill(props, gradientMap)) {
doLimits(p);
canvas.drawPath(p, paint);
}
if (doStroke(props, gradientMap)) {
canvas.drawPath(p, paint);
}
popTransform();
}
}
} else if (!hidden && localName.equals("path")) {
Path p = doPath(getStringAttr("d", atts));
pushTransform(atts);
Properties props = new Properties(atts);
if (doFill(props, gradientMap)) {
doLimits(p);
canvas.drawPath(p, paint);
}
if (doStroke(props, gradientMap)) {
canvas.drawPath(p, paint);
}
popTransform();
} else if (!hidden) {
// Log.d(TAG, "UNRECOGNIZED SVG COMMAND: " + localName);
}
}
/**
* 自定义的方法,简单绘制一些基本图形
*
* @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
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
int radius = 0;
int shadowColor = changeColorAlpha(mShadowColor, MIN_SHADOW_COLOR_ALPHA);
long elapsed = System.currentTimeMillis() - mStartTime;
switch (mState) {
case StateNormal:
shadowColor = changeColorAlpha(mShadowColor, MIN_SHADOW_COLOR_ALPHA);
break;
case StateTouchDown:
ripplePaint.setAlpha(255);
if (elapsed < ANIMATION_DURATION) {
radius = Math.round(elapsed * getWidth() / 2 / ANIMATION_DURATION);
float shadowAlpha =
(MAX_SHADOW_COLOR_ALPHA - MIN_SHADOW_COLOR_ALPHA) * elapsed / ANIMATION_DURATION
+ MIN_SHADOW_COLOR_ALPHA;
shadowColor = changeColorAlpha(mShadowColor, shadowAlpha);
} else {
radius = getWidth() / 2;
shadowColor = changeColorAlpha(mShadowColor, MAX_SHADOW_COLOR_ALPHA);
}
postInvalidate();
break;
case StateTouchUp:
if (elapsed < ANIMATION_DURATION) {
int alpha = Math.round((ANIMATION_DURATION - elapsed) * 255 / ANIMATION_DURATION);
ripplePaint.setAlpha(alpha);
radius = getWidth() / 2 + Math.round(elapsed * getWidth() / 2 / ANIMATION_DURATION);
float shadowAlpha =
(MAX_SHADOW_COLOR_ALPHA - MIN_SHADOW_COLOR_ALPHA)
* (ANIMATION_DURATION - elapsed)
/ ANIMATION_DURATION
+ MIN_SHADOW_COLOR_ALPHA;
shadowColor = changeColorAlpha(mShadowColor, shadowAlpha);
} else {
mState = StateNormal;
radius = 0;
ripplePaint.setAlpha(0);
shadowColor = changeColorAlpha(mShadowColor, MIN_SHADOW_COLOR_ALPHA);
}
postInvalidate();
break;
}
backgroundPaint.setShadowLayer(mShadowRadius, mShadowOffsetX, mShadowOffsetY, shadowColor);
canvas.drawRoundRect(getRectF(), mCornerRadius, mCornerRadius, backgroundPaint);
canvas.save();
if (mState == StateTouchDown || mState == StateTouchUp) {
if (rippleClipPath == null) {
rippleClipPath = new Path();
rippleClipPath.addRoundRect(getRectF(), mCornerRadius, mCornerRadius, Path.Direction.CW);
}
canvas.clipPath(rippleClipPath);
}
canvas.drawCircle(mTouchPoint.x, mTouchPoint.y, radius, ripplePaint);
canvas.restore();
if (mText != null && mText.length() > 0) {
int y = (int) (getHeight() / 2 - ((textPaint.descent() + textPaint.ascent()) / 2));
canvas.drawText(mText.toString(), getWidth() / 2, y, textPaint);
}
}
@Override
protected void onDraw(Canvas canvas) {
if (layout == null) {
requestLayout();
return;
}
if (description == null) {
return;
}
if (needNewUpdateTyping) {
updateTyping();
}
if (layout.isEncrypted) {
bounds(secureIcon, layout.layoutEncryptedLeft, layout.layoutEncryptedTop);
secureIcon.draw(canvas);
}
if (layout.titleLayout != null) {
canvas.save();
canvas.translate(layout.layoutTitleLeft, layout.layoutTitleLayoutTop);
layout.titleLayout.draw(canvas);
canvas.restore();
} else if (layout.titleString != null) {
TextPaint paint =
layout.isEncrypted
? titleEncryptedPaint
: (layout.isHighlighted ? titleHighlightPaint : titlePaint);
canvas.drawText(layout.titleString, layout.layoutTitleLeft, layout.layoutTitleTop, paint);
}
if (state != MessageState.FAILURE && description.getSenderId() == currentUserUid) {
switch (state) {
default:
case MessageState.PENDING:
bound(statePending, layout.layoutClockLeft, layout.layoutClockTop);
statePending.draw(canvas);
break;
case MessageState.SENT:
bound(stateSent, layout.layoutStateLeft, layout.layoutStateTop);
stateSent.draw(canvas);
break;
case MessageState.READED:
bound(stateSent, layout.layoutStateLeftDouble, layout.layoutStateTop);
stateSent.draw(canvas);
bound(stateHalfCheck, layout.layoutStateLeft, layout.layoutStateTop);
stateHalfCheck.draw(canvas);
break;
}
}
TextPaint timePaint =
HIGHLIGHT_UNDEAD ? (layout.isUnreadIn ? unreadClockPaint : readClockPaint) : readClockPaint;
canvas.drawText(layout.time, layout.layoutTimeLeft, layout.layoutTimeTop, timePaint);
if (typingLayout != null) {
canvas.save();
canvas.translate(layout.layoutMainLeft, layout.layoutMainContentTop);
typingLayout.draw(canvas);
canvas.restore();
} else if (layout.bodyLayout != null) {
canvas.save();
canvas.translate(layout.layoutMainLeft, layout.layoutMainContentTop);
layout.bodyLayout.draw(canvas);
canvas.restore();
} else if (layout.bodyString != null) {
// canvas.save();
// canvas.translate(layout.layoutMainLeft, layout.layoutMainTop);
// layout.bodyLayout.draw(canvas);
// canvas.restore();
canvas.drawText(layout.bodyString, layout.layoutMainLeft, layout.layoutMainTop, bodyPaint);
}
if (avatarHolder != null) {
long time = SystemClock.uptimeMillis() - avatarAppearTime;
if (time > AVATAR_FADE_TIME || !AVATAR_FADE) {
avatarPaint.setAlpha(255);
canvas.drawBitmap(
avatarHolder.getBitmap(), layout.layoutAvatarLeft, layout.layoutAvatarTop, avatarPaint);
} else {
drawPlaceHolder(canvas);
float alpha = time / (float) AVATAR_FADE_TIME;
avatarPaint.setAlpha((int) (255 * alpha));
canvas.drawBitmap(
avatarHolder.getBitmap(), layout.layoutAvatarLeft, layout.layoutAvatarTop, avatarPaint);
inavalidateForAnimation();
}
} else {
drawPlaceHolder(canvas);
}
if (description.isErrorState()
|| (state == MessageState.FAILURE && description.getSenderId() == currentUserUid)) {
bound(stateFailure, layout.layoutMarkLeft, layout.layoutMarkTop);
stateFailure.draw(canvas);
} else if (description.getUnreadCount() > 0) {
canvas.drawRoundRect(
layout.layoutMarkRect, layout.layoutMarkRadius, layout.layoutMarkRadius, counterPaint);
canvas.drawText(
layout.unreadCountText,
layout.layoutMarkLeft + layout.layoutMarkTextLeft,
layout.layoutMarkTextTop,
counterTitlePaint);
}
}
