java类android.graphics.LinearGradient的实例源码

/**
 * 添加倒影
 *
 * @param src              源图片的
 * @param reflectionHeight 倒影高度
 * @param recycle          是否回收
 * @return 带倒影图片
 */
public static Bitmap addReflection(final Bitmap src, final int reflectionHeight, final boolean recycle) {
    if (isEmptyBitmap(src)) {
        return null;
    }
    // 原图与倒影之间的间距
    final int reflectiongap = 0;
    int srcWidth = src.getWidth();
    int srcHeight = src.getHeight();
    Matrix matrix = new Matrix();
    matrix.preScale(1, -1);
    Bitmap reflectionBitmap = Bitmap.createBitmap(src, 0, srcHeight - reflectionHeight,
            srcWidth, reflectionHeight, matrix, false);
    Bitmap ret = Bitmap.createBitmap(srcWidth, srcHeight + reflectionHeight, src.getConfig());
    Canvas canvas = new Canvas(ret);
    canvas.drawBitmap(src, 0, 0, null);
    canvas.drawBitmap(reflectionBitmap, 0, srcHeight + reflectiongap, null);
    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
    LinearGradient shader = new LinearGradient(
            0, srcHeight,
            0, ret.getHeight() + reflectiongap,
            0x70FFFFFF,
            0x00FFFFFF,
            Shader.TileMode.MIRROR);
    paint.setShader(shader);
    paint.setXfermode(new PorterDuffXfermode(android.graphics.PorterDuff.Mode.DST_IN));
    canvas.drawRect(0, srcHeight + reflectiongap, srcWidth, ret.getHeight(), paint);
    if (!reflectionBitmap.isRecycled()) {
        reflectionBitmap.recycle();
    }
    if (recycle && !src.isRecycled()) {
        src.recycle();
    }
    return ret;
}

public static Bitmap modifyTrackCellArtworkBitmap(Bitmap source){
    if (source == null)
        return null;

    int w = source.getWidth();
    int h = source.getHeight();

    Bitmap scaled = Bitmap.createScaledBitmap(source, w, h, true);

    w = scaled.getWidth();
    h = scaled.getHeight();

    Bitmap overlay = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);

    Canvas canvas = new Canvas(overlay);
    final Paint paint = new Paint();

    canvas.drawBitmap(scaled, 0, 0, null);

    Shader shader = new LinearGradient(
            0, 0, h, 0,
            0x00FFFFFF, 0x77FFFFFF,
            Shader.TileMode.CLAMP
    );

    paint.setShader(shader);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));

    canvas.drawRect(0, 0, w, h, paint);

    return overlay;
}

private void init() {
    mPaint = new Paint();
    mPaint.setAntiAlias(true);
    mPaint.setStrokeCap(Paint.Cap.ROUND);// 圆角笔触
    mLeftLinearGradient = new LinearGradient(0, 0, mCy - OFFSET, mCy - OFFSET, 0xddffffff, 0x00000000, Shader.TileMode.CLAMP);
    mRightLinearGradient = new LinearGradient(mCy - OFFSET, mCy / 2, 0, mCy / 2, 0xddffffff, 0x00000000, Shader.TileMode.CLAMP);
}

private void drawArea(Canvas canvas, Line line) {
    final int lineSize = line.getValues().size();
    if (lineSize < 2) {
        //No point to draw area for one point or empty line.
        return;
    }

    final Rect contentRect = computator.getContentRectMinusAllMargins();
    final float baseRawValue = Math.min(contentRect.bottom, Math.max(computator.computeRawY(baseValue),
            contentRect.top));
    //That checks works only if the last point is the right most one.
    final float left = Math.max(computator.computeRawX(line.getValues().get(0).getX()), contentRect.left);
    final float right = Math.min(computator.computeRawX(line.getValues().get(lineSize - 1).getX()),
            contentRect.right);

    path.lineTo(right, baseRawValue);
    path.lineTo(left, baseRawValue);
    path.close();

    linePaint.setStyle(Paint.Style.FILL);
    linePaint.setAlpha(line.getAreaTransparency());
    linePaint.setShader(line.getGradientToTransparent() ?
            new LinearGradient(0, 0, 0, canvas.getHeight(), line.getColor(),
                    line.getColor() & 0x00ffffff, Shader.TileMode.MIRROR) :
            null);
    canvas.drawPath(path, linePaint);
    linePaint.setStyle(Paint.Style.STROKE);
}

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);
}

private LinearGradient getNewGradient(float barHeight, int color) {
    return new LinearGradient(
            0,
            0,
            0,
            barHeight,
            color,
            getScaledColor(color, GRADIENT_SCALE),
            Shader.TileMode.CLAMP);
}

/**
 * 添加倒影
 *
 * @param src 源图片的
 * @param reflectionHeight 倒影高度
 * @param recycle 是否回收
 * @return 带倒影图片
 */
public static Bitmap addReflection(Bitmap src, int reflectionHeight, boolean recycle) {
    if (isEmptyBitmap(src)) {
        return null;
    }
    // 原图与倒影之间的间距
    final int REFLECTION_GAP = 0;
    int srcWidth = src.getWidth();
    int srcHeight = src.getHeight();
    Matrix matrix = new Matrix();
    matrix.preScale(1, -1);
    Bitmap reflectionBitmap = Bitmap.createBitmap(src, 0, srcHeight -
            reflectionHeight, srcWidth, reflectionHeight, matrix, false);
    Bitmap ret = Bitmap.createBitmap(srcWidth,
            srcHeight + reflectionHeight, src.getConfig());
    Canvas canvas = new Canvas(ret);
    canvas.drawBitmap(src, 0, 0, null);
    canvas.drawBitmap(reflectionBitmap, 0,
            srcHeight + REFLECTION_GAP, null);
    Paint paint = new Paint();
    paint.setAntiAlias(true);
    LinearGradient shader = new LinearGradient(0, srcHeight, 0,
            ret.getHeight() +
                    REFLECTION_GAP, 0x70FFFFFF, 0x00FFFFFF, Shader.TileMode.MIRROR);
    paint.setShader(shader);
    paint.setXfermode(new PorterDuffXfermode(android.graphics.PorterDuff.Mode.DST_IN));
    canvas.drawRect(0,
            srcHeight + REFLECTION_GAP, srcWidth, ret.getHeight(), paint);
    if (!reflectionBitmap.isRecycled()) {
        reflectionBitmap.recycle();
    }
    if (recycle && !src.isRecycled()) {
        src.recycle();
    }
    return ret;
}

@SuppressLint("DrawAllocation")
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    int width = right - left;
    int height = bottom - top;

    int backHeight = getMeasuredHeight() - AndroidUtilities.dp(26) - AndroidUtilities.dp(64);
    gradientPaint.setShader(new LinearGradient(0, AndroidUtilities.dp(26), 0, backHeight + AndroidUtilities.dp(26), COLORS, LOCATIONS, Shader.TileMode.REPEAT));
    int x = width - AndroidUtilities.dp(26) - AndroidUtilities.dp(8);
    int y = AndroidUtilities.dp(26);
    rectF.set(x, y, x + AndroidUtilities.dp(8), y + backHeight);

    settingsButton.layout(width - settingsButton.getMeasuredWidth(), height - AndroidUtilities.dp(52), width, height);
}

@Override
protected void init() {
    shader = new LinearGradient(0,
            0,
            0,
            getHeight(),
            Color.BLUE,
            Color.GREEN,
            Shader.TileMode.MIRROR /*or REPEAT*/);
}

private void drawAlphaPanel(Canvas canvas) {
    if (!mShowAlphaPanel || mAlphaRect == null || mAlphaPattern == null) {
        return;
    }

    final RectF rect = mAlphaRect;

    if (BORDER_WIDTH_PX > 0) {
        mBorderPaint.setColor(mBorderColor);
        canvas.drawRect(rect.left - BORDER_WIDTH_PX,
                rect.top - BORDER_WIDTH_PX,
                rect.right + BORDER_WIDTH_PX,
                rect.bottom + BORDER_WIDTH_PX,
                mBorderPaint);
    }

    mAlphaPattern.draw(canvas);

    float[] hsv = new float[] {
            mHue, mSat, mVal
    };
    int color = Color.HSVToColor(hsv);
    int acolor = Color.HSVToColor(0, hsv);

    mAlphaShader = new LinearGradient(rect.left, rect.top, rect.right, rect.top,
            color, acolor, TileMode.CLAMP);

    mAlphaPaint.setShader(mAlphaShader);

    canvas.drawRect(rect, mAlphaPaint);

    if (mAlphaSliderText != null && mAlphaSliderText != "") {
        canvas.drawText(mAlphaSliderText, rect.centerX(), rect.centerY() + 4 * mDensity,
                mAlphaTextPaint);
    }

    float rectWidth = 4 * mDensity / 2;
    Point p = alphaToPoint(mAlpha);

    RectF r = new RectF();
    r.left = p.x - rectWidth;
    r.right = p.x + rectWidth;
    r.top = rect.top - RECTANGLE_TRACKER_OFFSET;
    r.bottom = rect.bottom + RECTANGLE_TRACKER_OFFSET;

    canvas.drawRoundRect(r, 2, 2, mHueTrackerPaint);
}