下面列出了android.graphics.drawable.ShapeDrawable.ShaderFactory#android.graphics.LinearGradient 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private void drawWaves(Canvas canvas) {
for (int i = 0; i < mWaveNumber; i++) {
float left = mWaveWidth * i + mWaveInterval * i;
float right = left + mWaveWidth;
float bottom = getHeight() - mBarHeight;
float fs = mWaveHeight[i];
float top;
top = bottom - mWaveMinHeight - (fs * mWaveRange);
LinearGradient lg = new LinearGradient(
left, bottom,
right, top,
mWaveColors[i],
null,
Shader.TileMode.CLAMP
);
mPaint.setAlpha(255);
mPaint.setShader(lg);
canvas.drawRoundRect(left, top, right, bottom + 2, 20, 20, mPaint);
}
}
private void downLgMoreCofig(Canvas canvas){
// 设置渐变曲线配置
float y0 = control1.y;
LinearGradient lg = new LinearGradient(mRadius * 2, y0, mView_W / 2, control2.y + DensityUtil.dp2px(2),
Color.rgb(88, 181, 250), Color.rgb(101, 226, 175), Shader.TileMode.CLAMP);
mPaint.setShader(lg);
// 画虚线
canvas.drawLine(mRadius + mPointPaint.getStrokeWidth(), mRadius * 2 + mPointPaint.getStrokeWidth(),
mRadius + mPointPaint.getStrokeWidth(), mView_H - mRadius * 2 - mPointPaint.getStrokeWidth(), mImaPaint);
// 画圆点
mPointPaint.setShader(lg);
canvas.drawCircle(mRadius + mPointPaint.getStrokeWidth(), control1.y, mRadius, mPointPaint);
canvas.drawCircle(mView_W - mRadius - mPointPaint.getStrokeWidth(), control2.y, mRadius, mPointPaint);
}
@Override public void onInit(CandleRender render, AbsChartModule chartModule) {
super.onInit(render, chartModule);
attribute = render.getAttribute();
borderPaint.setStyle(Paint.Style.STROKE);
borderPaint.setStrokeWidth(attribute.borderWidth);
borderPaint.setColor(attribute.borderColor);
timelinePaint.setStrokeWidth(attribute.timeLineWidth);
timelinePaint.setColor(attribute.timeLineColor);
timelinePaint.setStyle(Paint.Style.STROKE);
timeShaderPaint.setShader(
new LinearGradient(0, viewRect.top, 0, viewRect.bottom,
new int[] { attribute.timeLineShaderColorBegin, attribute.timeLineShaderColorEnd },
null, Shader.TileMode.REPEAT));
space = (attribute.candleSpace / attribute.candleWidth) / 2;
}
@Override
public void onDraw(Canvas canvas) {
super.onDraw(canvas);
float width = getWidth();
float height = getHeight();
if (isEnabled()) {
LinearGradient grad = new LinearGradient(height / 2, 0.0f,
width - height / 2, 0.0f,
spectrumColors, null, Shader.TileMode.CLAMP);
brush.setShader(grad);
canvas.drawRect(height / 2, (height - lineHeight) / 2,
width - height / 2, (height + lineHeight) / 2,
brush);
}
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mWidth = getWidth();
mRectHeight = getHeight();
mRectWidth = (int) (mWidth * 0.6 / mRectCount);
mLinearGradient = new LinearGradient(
0,
0,
mRectWidth,
mRectHeight,
Color.YELLOW,
Color.BLUE,
Shader.TileMode.CLAMP);
mPaint.setShader(mLinearGradient);
}
/**
* Set the bar color. <br>
* <br>
* Its discouraged to use this method.
*
* @param color
*/
public void setColor(int color) {
int x1, y1;
if(mOrientation == ORIENTATION_HORIZONTAL) {
x1 = (mBarLength + mBarPointerHaloRadius);
y1 = mBarThickness;
}
else {
x1 = mBarThickness;
y1 = (mBarLength + mBarPointerHaloRadius);
}
Color.colorToHSV(color, mHSVColor);
shader = new LinearGradient(mBarPointerHaloRadius, 0,
x1, y1, new int[] {
color, Color.BLACK }, null, Shader.TileMode.CLAMP);
mBarPaint.setShader(shader);
calculateColor(mBarPointerPosition);
mBarPointerPaint.setColor(mColor);
if (mPicker != null) {
mPicker.setNewCenterColor(mColor);
if(mPicker.hasOpacityBar())
mPicker.changeOpacityBarColor(mColor);
}
invalidate();
}
public static Bitmap getReverseBitmapById(Context context, int resId, float percent) {
// get the source bitmap
Bitmap srcBitmap=BitmapFactory.decodeResource(context.getResources(), resId);
// get the tow third segment of the reverse bitmap
Matrix matrix=new Matrix();
matrix.setScale(1, -1);
Bitmap rvsBitmap=Bitmap.createBitmap(srcBitmap, 0, (int) (srcBitmap.getHeight()*(1-percent)),
srcBitmap.getWidth(), (int) (srcBitmap.getHeight()*percent), matrix, false);
// combine the source bitmap and the reverse bitmap
Bitmap comBitmap=Bitmap.createBitmap(srcBitmap.getWidth(),
srcBitmap.getHeight()+rvsBitmap.getHeight()+20, srcBitmap.getConfig());
Canvas gCanvas=new Canvas(comBitmap);
gCanvas.drawBitmap(srcBitmap, 0, 0, null);
gCanvas.drawBitmap(rvsBitmap, 0, srcBitmap.getHeight()+20, null);
Paint paint=new Paint();
LinearGradient shader=new LinearGradient(0, srcBitmap.getHeight()+20, 0, comBitmap.getHeight(),
Color.BLACK, Color.TRANSPARENT, Shader.TileMode.CLAMP);
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
gCanvas.drawRect(0, srcBitmap.getHeight()+20, srcBitmap.getWidth(), comBitmap.getHeight(), paint);
return comBitmap;
}
public Bitmap addGradient(Bitmap originalBitmap){
int width = originalBitmap.getWidth();
int height = originalBitmap.getHeight();
Bitmap updatedBitmap = Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(updatedBitmap);
canvas.drawBitmap(originalBitmap,0,0,null);
Paint paint = new Paint();
LinearGradient shader = new LinearGradient(0,0,0,height,getResources().getColor(R.color.colorAccent),getResources().getColor(R.color.colorAccent1), Shader.TileMode.CLAMP);
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawRect(0,0,width,height,paint);
return updatedBitmap;
}
/**
* 绘制扫描线
*/
private void drawLaserScanner(Canvas canvas) {
paint.setColor(lineColor);
//线性渐变
LinearGradient linearGradient = new LinearGradient(
0, scannerStart,
0, scannerStart + SCANNER_LINE_HEIGHT,
shadeColor(lineColor),
lineColor,
Shader.TileMode.MIRROR);
paint.setShader(linearGradient);
if (scannerStart <= scannerEnd) {
//椭圆
RectF rectF = new RectF(2 * SCANNER_LINE_HEIGHT, scannerStart, width - 2 * SCANNER_LINE_HEIGHT, scannerStart + SCANNER_LINE_HEIGHT);
canvas.drawOval(rectF, paint);
scannerStart += SCANNER_LINE_MOVE_DISTANCE;
} else {
scannerStart = 0;
}
paint.setShader(null);
}
private void ensureShadowShader() {
shaderColors[0] = shaderColor;
shaderColors[1] = Color.TRANSPARENT;
if (shaderWrapper.isDifferent(
getMeasuredWidth(), getMeasuredHeight(), false, shaderColors)) {
shaderWrapper.setShader(
new LinearGradient(
0, rectF.top,
0, rectF.bottom,
shaderColors[0], shaderColors[1],
Shader.TileMode.CLAMP
),
getMeasuredWidth(), getMeasuredHeight(),
false,
shaderColors
);
}
}
private Bitmap createReflection(Bitmap original, float percentage, int gap) {
final int reflectionHeight = (int) (original.getHeight() * percentage);
Bitmap bitmapWithReflection = Bitmap.createBitmap(original.getWidth(), (original.getHeight() + reflectionHeight + gap), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmapWithReflection);
// original image
canvas.drawBitmap(original, 0, 0, null);
// gap drawing
final Paint transparentPaint = new Paint();
transparentPaint.setARGB(0, 255, 255, 255);
canvas.drawRect(0, original.getHeight(), original.getWidth(), original.getHeight() + gap, transparentPaint);
// reflection
final Matrix matrix = new Matrix();
matrix.preScale(1, -1);
canvas.drawBitmap(Bitmap.createBitmap(original, 0, original.getHeight() - reflectionHeight, original.getWidth(), reflectionHeight, matrix, false), 0, original.getHeight() + gap, null);
// reflection shading
final Paint fadePaint = new Paint();
fadePaint.setShader(new LinearGradient(0, original.getHeight(), 0, original.getHeight() + reflectionHeight + gap, 0x70ffffff, 0x00ffffff, Shader.TileMode.CLAMP));
fadePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));
canvas.drawRect(0, original.getHeight(), original.getWidth(), bitmapWithReflection.getHeight() + gap, fadePaint);
original.recycle();
return bitmapWithReflection;
}
public static Drawable drawable(final int[] colorBoxes, final float[] position, final GradientAngle gradientAngle) {
ShapeDrawable.ShaderFactory shaderFactory = new ShapeDrawable.ShaderFactory() {
@Override
public Shader resize(int width, int height) {
AngleCoordinate ac = AngleCoordinate.getAngleCoordinate(gradientAngle, width, height);
LinearGradient linearGradient = new LinearGradient(ac.x1, ac.y1, ac.x2, ac.y2,
colorBoxes,
position,
Shader.TileMode.REPEAT);
return linearGradient;
}
};
PaintDrawable paint = new PaintDrawable();
paint.setShape(new RectShape());
paint.setShaderFactory(shaderFactory);
return paint;
}
public Bitmap addGradient(Bitmap originalBitmap){
int width = originalBitmap.getWidth();
int height = originalBitmap.getHeight();
Bitmap updatedBitmap = Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(updatedBitmap);
canvas.drawBitmap(originalBitmap,0,0,null);
Paint paint = new Paint();
LinearGradient shader = new LinearGradient(0,0,0,height,getResources().getColor(R.color.colorAccent),getResources().getColor(R.color.colorAccent1), Shader.TileMode.CLAMP);
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
canvas.drawRect(0,0,width,height,paint);
return updatedBitmap;
}
/**
* Set the bar color. <br>
* <br>
* Its discouraged to use this method.
*
* @param color
*/
public void setColor(int color) {
int x1, y1;
if (mOrientation == ORIENTATION_HORIZONTAL) {
x1 = (mBarLength + mBarPointerHaloRadius);
y1 = mBarThickness;
} else {
x1 = mBarThickness;
y1 = (mBarLength + mBarPointerHaloRadius);
}
Color.colorToHSV(color, mHSVColor);
shader = new LinearGradient(mBarPointerHaloRadius, 0,
x1, y1, new int[]{
Color.HSVToColor(0x00, mHSVColor), color}, null,
Shader.TileMode.CLAMP);
mBarPaint.setShader(shader);
calculateColor(mBarPointerPosition);
mBarPointerPaint.setColor(mColor);
if (mPicker != null) {
mPicker.setNewCenterColor(mColor);
}
invalidate();
}
/**
* Set the bar color. <br>
* <br>
* Its discouraged to use this method.
*
* @param color
*/
public void setColor(int color) {
int x1, y1;
if(mOrientation) {
x1 = (mBarLength + mBarPointerHaloRadius);
y1 = mBarThickness;
} else {
x1 = mBarThickness;
y1 = (mBarLength + mBarPointerHaloRadius);
}
Color.colorToHSV(color, mHSVColor);
shader = new LinearGradient(mBarPointerHaloRadius, 0,
x1, y1, new int[] {Color.WHITE, color, Color.BLACK}, null,
Shader.TileMode.CLAMP);
mBarPaint.setShader(shader);
calculateColor(mBarPointerPosition);
mBarPointerPaint.setColor(mColor);
if (mPicker != null) {
mPicker.setNewCenterColor(mColor);
if(mPicker.hasOpacityBar())
mPicker.changeOpacityBarColor(mColor);
}
invalidate();
}
@Override
public void draw(Canvas canvas) {
Rect b = getBounds();
Paint huePaint = new Paint();
huePaint.setShader(new LinearGradient(0, 0, b.width(), 0,
new int[]{
0xFFFF0000,
0xFFFFFF00,
0xFF00FF00,
0xFF00FFFF,
0xFF0000FF,
0xFFFF00FF,
0xFFFF0000
},
null,
Shader.TileMode.REPEAT)
);
canvas.drawRect(b, huePaint);
}
/**
* Set the bar color. <br>
* <br>
* Its discouraged to use this method.
*
* @param color
*/
public void setColor(int color) {
int x1, y1;
if(mOrientation) {
x1 = (mBarLength + mBarPointerHaloRadius);
y1 = mBarThickness;
} else {
x1 = mBarThickness;
y1 = (mBarLength + mBarPointerHaloRadius);
}
Color.colorToHSV(color, mHSVColor);
shader = new LinearGradient(mBarPointerHaloRadius, 0,
x1, y1, new int[] {Color.WHITE, color, Color.BLACK}, null,
Shader.TileMode.CLAMP);
mBarPaint.setShader(shader);
calculateColor(mBarPointerPosition);
mBarPointerPaint.setColor(mColor);
if (mPicker != null) {
mPicker.setNewCenterColor(mColor);
if(mPicker.hasOpacityBar())
mPicker.changeOpacityBarColor(mColor);
}
invalidate();
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
viewWidth = w;
viewHeight = h;
if (viewWidth <= 0 || viewHeight <= 0) return;
int barWidth = (int) (viewWidth * INDICATOR_TO_BAR_WIDTH_RATIO);
centerX = viewWidth / 2;
indicatorRadius = (viewWidth / 2) - borderWidth;
colorPickerRadius = (barWidth / 2) - borderWidth;
colorPickerBody = new RectF(centerX - colorPickerRadius,
borderWidth + colorPickerRadius + indicatorRadius,
centerX + colorPickerRadius,
viewHeight - (borderWidth + colorPickerRadius + indicatorRadius));
LinearGradient gradient = new LinearGradient(0, colorPickerBody.top, 0, colorPickerBody.bottom, colors, null, Shader.TileMode.CLAMP);
paint.setShader(gradient);
if (bitmap != null) {
bitmap.recycle();
}
bitmap = Bitmap.createBitmap(viewWidth, viewHeight, Bitmap.Config.ARGB_8888);
bitmapCanvas = new Canvas(bitmap);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mSaturationGradient = new LinearGradient(getPaddingLeft(), 0,
w - getPaddingRight(), 0,
0xFFFFFFFF, 0x00FFFFFF, Shader.TileMode.CLAMP);
mSaturationGradientPaint.setShader(mSaturationGradient);
mValueGradient = new LinearGradient(0, getPaddingTop(), 0,
h - getPaddingRight(),
0x00000000, 0xFF000000, Shader.TileMode.CLAMP);
mValueGradientPaint.setShader(mValueGradient);
}
private void updatePlaceholder() {
if (placeholderPaint == null) {
return;
}
int color0 = Theme.getColor(Theme.key_dialogBackground);
int color1 = Theme.getColor(Theme.key_dialogBackgroundGray);
color0 = AndroidUtilities.getAverageColor(color1, color0);
placeholderPaint.setColor(color1);
placeholderGradient = new LinearGradient(0, 0, gradientWidth = AndroidUtilities.dp(500), 0, new int[]{color1, color0, color1}, new float[]{0.0f, 0.18f, 0.36f}, Shader.TileMode.REPEAT);
placeholderPaint.setShader(placeholderGradient);
placeholderMatrix = new Matrix();
placeholderGradient.setLocalMatrix(placeholderMatrix);
}
/**
* 获得带倒影的Bitmap
*
* @param bitmap 源Bitmap
* @return 带倒影的Bitmap
*/
public static Bitmap createReflectionBitmap(Bitmap bitmap) {
final int reflectionGap = 4;
int width = bitmap.getWidth();
int height = bitmap.getHeight();
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height / 2,
width, height / 2, matrix, false);
Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
(height + height / 2), Config.ARGB_8888);
Canvas canvas = new Canvas(bitmapWithReflection);
canvas.drawBitmap(bitmap, 0, 0, null);
Paint deafalutPaint = new Paint();
canvas.drawRect(0, height, width, height + reflectionGap, deafalutPaint);
canvas.drawBitmap(reflectionImage, 0, height + reflectionGap, null);
Paint paint = new Paint();
LinearGradient shader = new LinearGradient(0, bitmap.getHeight(), 0,
bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff,
0x00ffffff, TileMode.CLAMP);
paint.setShader(shader);
// Set the Transfer mode to be porter duff and destination in
paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
// Draw a rectangle using the paint with our linear gradient
canvas.drawRect(0, height, width, bitmapWithReflection.getHeight()
+ reflectionGap, paint);
return bitmapWithReflection;
}
protected void initPainters() {
if (showText) {
textPaint = new TextPaint();
textPaint.setColor(textColor);
textPaint.setTextSize(textSize);
textPaint.setAntiAlias(true);
innerBottomTextPaint = new TextPaint();
innerBottomTextPaint.setColor(innerBottomTextColor);
innerBottomTextPaint.setTextSize(innerBottomTextSize);
innerBottomTextPaint.setAntiAlias(true);
}
finishedPaint = new Paint();
//finishedPaint.setShader(new SweepGradient(0, 0, Color.BLUE, Color.YELLOW));
if (gradientColorOne != 0 && gradientColorTwo != 0) {
finishedPaint.setShader(new LinearGradient(0, 0, 0, getHeight(), gradientColorOne, gradientColorTwo, Shader.TileMode.MIRROR));
} else {
finishedPaint.setColor(finishedStrokeColor);
}
finishedPaint.setStyle(Paint.Style.STROKE);
finishedPaint.setAntiAlias(true);
finishedPaint.setStrokeWidth(finishedStrokeWidth);
unfinishedPaint = new Paint();
unfinishedPaint.setColor(unfinishedStrokeColor);
unfinishedPaint.setStyle(Paint.Style.STROKE);
unfinishedPaint.setAntiAlias(true);
unfinishedPaint.setStrokeWidth(unfinishedStrokeWidth);
innerCirclePaint = new Paint();
innerCirclePaint.setColor(innerBackgroundColor);
innerCirclePaint.setAntiAlias(true);
}
private void upLgMoreConfig(Canvas canvas){
LinearGradient lg = new LinearGradient(mRadius * 2, control1.y, mView_W / 2, control2.y + DensityUtil.dp2px(2),
Color.rgb(255, 196, 0), Color.rgb(255, 105, 83), Shader.TileMode.CLAMP);
mPaint.setShader(lg);
// 画虚线
canvas.drawLine(mView_W - mRadius - mPointPaint.getStrokeWidth(), mRadius * 2 + mPointPaint.getStrokeWidth(),
mView_W - mRadius - mPointPaint.getStrokeWidth(), mView_H - mRadius * 2 - mPointPaint.getStrokeWidth(), mImaPaint);
// 画圆点
mPointPaint.setShader(lg);
canvas.drawCircle(mRadius + mPointPaint.getStrokeWidth(), mView_H - mRadius - mPointPaint.getStrokeWidth(), mRadius, mPointPaint);
canvas.drawCircle(mView_W - mRadius - mPointPaint.getStrokeWidth(), control2.y + DensityUtil.dp2px(2), mRadius, mPointPaint);
}
/**
* 绘制进度条背景
*
* @param canvas
* @param reachedEndX
*/
private void drawProgressBg(Canvas canvas, float reachedEndX) {
mBgPaint.setStrokeWidth(mUnReachedHeight);
if (mBgGradientColor == null) { // 默认
mBgPaint.setColor(mUnReachedColor);
canvas.drawLine(0, 0, mMaxUnReachedEndX, 0, mBgPaint);
} else { // 渐变
mBgPaint.setShader(new LinearGradient(mMaxUnReachedEndX - reachedEndX, 0, mMaxUnReachedEndX, 0,
mBgGradientColor.getStartColor(), mBgGradientColor.getEndColor(),
Shader.TileMode.CLAMP));
canvas.drawLine(0, 0, mMaxUnReachedEndX, 0, mBgPaint);
}
}
public Shader getLinearGradient(GradientAngle gradientAngle, float width, float height) {
float x1 = 0, x2 = 0, y1 = 0, y2 = 0;
switch (gradientAngle) {
case LEFT_TO_RIGHT:
x2 = width;
break;
case RIGHT_TO_LEFT:
x1 = width;
break;
case TOP_TO_BOTTOM:
y2 = height;
break;
case BOTTOM_TO_TOP:
y1 = height;
break;
case LEFT_TOP_TO_RIGHT_BOTTOM:
x2 = width;
y2 = height;
break;
case RIGHT_BOTTOM_TO_LEFT_TOP:
x1 = width;
y1 = height;
break;
case LEFT_BOTTOM_TO_RIGHT_TOP:
x2 = width;
y1 = height;
break;
case RIGHT_TOP_TO_LEFT_BOTTOM:
x1 = width;
y2 = height;
break;
}
return new LinearGradient(x1, y1, x2, y2, startColor, endColor, Shader.TileMode.CLAMP);
}
protected void updateRainbow() {
animationAngle = (animationAngle + 1) % 360;
//Animation matrix:
int[] rainbow = {Color.RED, Color.YELLOW, Color.GREEN, Color.BLUE
, Color.CYAN};
Shader shader = new LinearGradient(0, 0, 0, 20, rainbow,
null, Shader.TileMode.MIRROR);
Matrix matrix = new Matrix();
matrix.setRotate(animationAngle);
shader.setLocalMatrix(matrix);
mSgv.getPaint().setShader(shader);
invalidate();
}
private void drawBackground(Canvas canvas) {
final long currentTime = System.currentTimeMillis();
final int width = canvas.getWidth();
final int height = canvas.getHeight();
// first time
if (mLastDrawCanvasTime == 0L) {
mLastDrawCanvasTime = currentTime;
}
// update delta pixel
final long deltaTime = currentTime - mLastDrawCanvasTime;
if (deltaTime >= FPS) {
mLastDrawCanvasTime = currentTime;
final float addedDeltaPixel = VELOCITY * deltaTime;
mDeltaPixel += addedDeltaPixel;
float pathLength = height;
if (mDeltaPixel > pathLength) {
mDeltaPixel %= pathLength;
}
}
// draw
LinearGradient linearGradient = new LinearGradient(
0 - mDeltaPixel, -mDeltaPixel,
height - mDeltaPixel, height - mDeltaPixel,
COLORS,
POSITIONS,
Shader.TileMode.REPEAT);
mRgbPaint.setShader(linearGradient);
canvasRect.left = 0;
canvasRect.top = 0;
canvasRect.right = width;
canvasRect.bottom = height;
canvas.drawRect(canvasRect, mRgbPaint);
}
AsyncPaintPosition createGradientPaint(Style s) {
final Paint paint = new Paint();
paint.setStyle(Paint.Style.FILL);
paint.setAntiAlias(true);
paint.setAlpha(255);
final byte bgType = s.getBackgroundType();
final int startColor = s.getBackgroundGradientStartColor();
final int endColor = s.getBackgroundGradientEndColor();
AsyncPaintPosition ap = new AsyncPaintPosition(clip, clipP, clipIsPath) {
int lastHeight;
int lastWidth;
@Override
public void executeImpl(AndroidGraphics underlying) {
if(width != lastWidth || height != lastHeight) {
lastWidth = width;
lastHeight = height;
switch(bgType) {
case Style.BACKGROUND_GRADIENT_LINEAR_VERTICAL:
paint.setShader(new LinearGradient(0, 0, 0, height, startColor, endColor, Shader.TileMode.MIRROR));
break;
case Style.BACKGROUND_GRADIENT_LINEAR_HORIZONTAL:
paint.setShader(new LinearGradient(0, 0, width, 0, startColor, endColor, Shader.TileMode.MIRROR));
break;
case Style.BACKGROUND_GRADIENT_RADIAL:
paint.setShader(new RadialGradient(x, y, Math.max(width, height), startColor, endColor, Shader.TileMode.MIRROR));
break;
}
underlying.canvas.drawRect(x, y, x + width, y + height, paint);
}
}
public String toString() {
return "GradientPaint";
}
};
return ap;
}
private void createShader() {
Rect bounds = getBounds();
if (bounds.isEmpty()) return;
final int radius = Math.max(bounds.width(), bounds.height()) / 2;
mShader1 = new LinearGradient(0, 0, radius, 0, mColor1, mBackgroundColor, Shader.TileMode.CLAMP);
mShader2 = new LinearGradient(0, 0, radius, 0, mColor2, mBackgroundColor, Shader.TileMode.CLAMP);
}
public static Bitmap createCutReflectedImage(Bitmap bitmap, int cutHeight) {
int width = bitmap.getWidth();
int height = bitmap.getHeight();
int totalHeight = mReflectImageHeight + cutHeight;
if (height <= totalHeight) {
return null;
}
Matrix matrix = new Matrix();
matrix.preScale(1, -1);
Bitmap reflectionImage = Bitmap.createBitmap(bitmap, 0, height
- mReflectImageHeight - cutHeight, width, mReflectImageHeight,
matrix, true);
Bitmap bitmapWithReflection = Bitmap.createBitmap(width,
mReflectImageHeight, Config.ARGB_8888);
Canvas canvas = new Canvas(bitmapWithReflection);
canvas.drawBitmap(reflectionImage, 0, 0, null);
LinearGradient shader = new LinearGradient(0, 0, 0,
bitmapWithReflection.getHeight(), 0x80ffffff, 0x00ffffff,
TileMode.CLAMP);
Paint paint = new Paint();
paint.setShader(shader);
paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN));
canvas.drawRect(0, 0, width, bitmapWithReflection.getHeight(), paint);
if (!reflectionImage.isRecycled()) {
reflectionImage.recycle();
}
System.gc();
return bitmapWithReflection;
}