Example usage for android.graphics Color alpha

Introduction

In this page you can find the example usage for android.graphics Color alpha.

Prototype

@IntRange(from = 0, to = 255)
public static int alpha(int color) 

Source Link

Document

Return the alpha component of a color int.

Usage

From source file:Main.java

/**
 * This helper method creates a 'nice' scrim or background protection for layering text over
 * an image. This non-linear scrim is less noticable than a linear or constant one.
 *
 * Borrowed from github.com/romannurik/muzei
 *
 * Creates an approximated cubic gradient using a multi-stop linear gradient. See
 * <a href="https://plus.google.com/+RomanNurik/posts/2QvHVFWrHZf">this post</a> for more
 * details.// w  w w  . j a v a  2  s .  c  om
 */
public static Drawable makeCubicGradientScrimDrawable(int baseColor, int numStops, int gravity) {
    numStops = Math.max(numStops, 2);

    PaintDrawable paintDrawable = new PaintDrawable();
    paintDrawable.setShape(new RectShape());

    final int[] stopColors = new int[numStops];

    int alpha = Color.alpha(baseColor);

    for (int i = 0; i < numStops; i++) {
        double x = i * 1f / (numStops - 1);
        double opacity = Math.max(0, Math.min(1, Math.pow(x, 3)));
        stopColors[i] = (baseColor & 0x00ffffff) | ((int) (alpha * opacity) << 24);
    }

    final float x0, x1, y0, y1;
    switch (gravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
    case Gravity.LEFT:
        x0 = 1;
        x1 = 0;
        break;
    case Gravity.RIGHT:
        x0 = 0;
        x1 = 1;
        break;
    default:
        x0 = 0;
        x1 = 0;
        break;
    }
    switch (gravity & Gravity.VERTICAL_GRAVITY_MASK) {
    case Gravity.TOP:
        y0 = 1;
        y1 = 0;
        break;
    case Gravity.BOTTOM:
        y0 = 0;
        y1 = 1;
        break;
    default:
        y0 = 0;
        y1 = 0;
        break;
    }

    paintDrawable.setShaderFactory(new ShapeDrawable.ShaderFactory() {
        @Override
        public Shader resize(int width, int height) {
            LinearGradient linearGradient = new LinearGradient(width * x0, height * y0, width * x1, height * y1,
                    stopColors, null, Shader.TileMode.CLAMP);
            return linearGradient;
        }
    });

    return paintDrawable;
}

---

From source file:com.pranavpandey.smallapp.theme.DynamicTheme.java

/**
 * Calculate tint based on a given color for better readability.
 *
 * @param color whose tint to be calculated.
 *
 * @return Tint of color.// w w  w . ja  v  a  2s.co  m
 */
public static @ColorInt int getTintColor(@ColorInt int color) {
    int finalColor;
    double tint;
    int a = Color.alpha(color);
    int r = Color.red(color);
    int g = Color.green(color);
    int b = Color.blue(color);
    double colorDarkness = getColorDarkness(color);
    boolean isColorDark;

    if (isColorDark = isColorDark(color)) {
        if (colorDarkness >= 0.5f && colorDarkness < 0.6f) {
            tint = 0.9f;
        } else if (colorDarkness >= 0.6f && colorDarkness < 0.65f) {
            tint = 0.8f;
        } else {
            tint = 0.7f;
        }
        finalColor = Color.argb(a, (int) (r + (tint * (255 - r))), (int) (g + (tint * (255 - g))),
                (int) (b + (tint * (255 - b))));
    } else {
        if (colorDarkness < 0.5f && colorDarkness >= 0.4f) {
            tint = 0.4f;
        } else if (colorDarkness < 0.4f && colorDarkness >= 0.3f) {
            tint = 0.5f;
        } else {
            tint = 0.6f;
        }
        finalColor = Color.argb((int) Math.min(1.33 * a, 255), (int) (r * tint), (int) (g * tint),
                (int) (b * tint));
    }

    if (calculateContrast(color, finalColor) < 0.3f) {
        int newTint = 25;
        if (isColorDark) {
            newTint = 225;
        }
        finalColor = Color.argb(a, newTint, newTint, newTint);
    }
    return finalColor;
}

---

From source file:net.yanzm.actionbarprogress.ThemeUtils.java

public static int getThemeAttrColor(@NonNull Context context, int attr, float alpha) {
    final int color = getThemeAttrColor(context, attr);
    final int originalAlpha = Color.alpha(color);

    // Return the color, multiplying the original alpha by the disabled value
    return (color & 0x00ffffff) | (Math.round(originalAlpha * alpha) << 24);
}

---

From source file:Main.java

/**
 * Composite two potentially translucent colors over each other and returns the result.
 *///from   w w w  .  j a v  a 2 s  .  co  m
public static int compositeColors(int foreground, int background) {
    final float alpha1 = Color.alpha(foreground) / 255f;
    final float alpha2 = Color.alpha(background) / 255f;

    float a = (alpha1 + alpha2) * (1f - alpha1);
    float r = (Color.red(foreground) * alpha1) + (Color.red(background) * alpha2 * (1f - alpha1));
    float g = (Color.green(foreground) * alpha1) + (Color.green(background) * alpha2 * (1f - alpha1));
    float b = (Color.blue(foreground) * alpha1) + (Color.blue(background) * alpha2 * (1f - alpha1));

    return Color.argb((int) a, (int) r, (int) g, (int) b);
}

---

From source file:io.plaidapp.core.util.ScrimUtil.java

/**
 * Creates an approximated cubic gradient using a multi-stop linear gradient. See
 * <a href="https://plus.google.com/+RomanNurik/posts/2QvHVFWrHZf">this post</a> for more
 * details.// w w  w.java 2s  .c  om
 */
public static Drawable makeCubicGradientScrimDrawable(@ColorInt int baseColor, int numStops, int gravity) {
    numStops = Math.max(numStops, 2);

    PaintDrawable paintDrawable = new PaintDrawable();
    paintDrawable.setShape(new RectShape());

    final int[] stopColors = new int[numStops];

    int alpha = Color.alpha(baseColor);

    for (int i = 0; i < numStops; i++) {
        float x = i * 1f / (numStops - 1);
        float opacity = MathUtils.clamp((float) Math.pow(x, 3), 0, 1);
        stopColors[i] = ColorUtils.modifyAlpha(baseColor, (int) (alpha * opacity));
    }

    final float x0, x1, y0, y1;
    switch (gravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
    case Gravity.LEFT:
        x0 = 1;
        x1 = 0;
        break;
    case Gravity.RIGHT:
        x0 = 0;
        x1 = 1;
        break;
    default:
        x0 = 0;
        x1 = 0;
        break;
    }
    switch (gravity & Gravity.VERTICAL_GRAVITY_MASK) {
    case Gravity.TOP:
        y0 = 1;
        y1 = 0;
        break;
    case Gravity.BOTTOM:
        y0 = 0;
        y1 = 1;
        break;
    default:
        y0 = 0;
        y1 = 0;
        break;
    }

    paintDrawable.setShaderFactory(new ShapeDrawable.ShaderFactory() {
        @Override
        public Shader resize(int width, int height) {
            LinearGradient linearGradient = new LinearGradient(width * x0, height * y0, width * x1, height * y1,
                    stopColors, null, Shader.TileMode.CLAMP);
            return linearGradient;
        }
    });

    return paintDrawable;
}

---

From source file:com.waz.zclient.ui.utils.ColorUtils.java

public static int getPressColor(int alpha, int borderColor) {
    int borderColorPressed;
    if (Color.alpha(borderColor) == 0) {
        borderColorPressed = borderColor;
    } else {/*from   www  . ja  va2 s . c o m*/
        borderColorPressed = ColorUtils.injectAlpha(alpha, borderColor);
    }
    return borderColorPressed;
}

---

From source file:Main.java

/**
 * Create a bitmap that contains the transformation to make to create the final 
 * bitmap with a new tint color. You can then call processTintTransformationMap() 
 * to get a bitmap with the desired tint.
 * @param bitmap The original bitmap.//  ww  w .j  a va 2s. c o m
 * @param tintColor Tint color in the original bitmap.
 * @return A transformation map to be used with processTintTransformationMap(). The 
 * transformation values are stored in the red and green values. The alpha value is 
 * significant and the blue value can be ignored.
 */
public static Bitmap createTintTransformationMap(Bitmap bitmap, int tintColor) {
    // tint color
    int[] t = new int[] { Color.red(tintColor), Color.green(tintColor), Color.blue(tintColor) };

    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    int[] pixels = new int[width * height];
    bitmap.getPixels(pixels, 0, width, 0, 0, width, height);

    int maxIndex = getMaxIndex(t);
    int mintIndex = getMinIndex(t);

    for (int i = 0; i < pixels.length; i++) {
        int color = pixels[i];
        // pixel color
        int[] p = new int[] { Color.red(color), Color.green(color), Color.blue(color) };
        int alpha = Color.alpha(color);

        float[] transformation = calculateTransformation(t[maxIndex], t[mintIndex], p[maxIndex], p[mintIndex]);
        pixels[i] = Color.argb(alpha, (int) (transformation[0] * 255), (int) (transformation[1] * 255), 0);
    }
    return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
}

---

From source file:Main.java

/**
 * Creates an approximated cubic gradient using a multi-stop linear gradient.
 *///  ww  w.j av  a2  s  .co m
public static Drawable makeCubicGradientScrimDrawable(int baseColor, int numStops, int gravity) {

    // Generate a cache key by hashing together the inputs, based on the method described in the Effective Java book
    int cacheKeyHash = baseColor;
    cacheKeyHash = 31 * cacheKeyHash + numStops;
    cacheKeyHash = 31 * cacheKeyHash + gravity;

    Drawable cachedGradient = cubicGradientScrimCache.get(cacheKeyHash);
    if (cachedGradient != null) {
        return cachedGradient;
    }

    numStops = Math.max(numStops, 2);

    PaintDrawable paintDrawable = new PaintDrawable();
    paintDrawable.setShape(new RectShape());

    final int[] stopColors = new int[numStops];

    int red = Color.red(baseColor);
    int green = Color.green(baseColor);
    int blue = Color.blue(baseColor);
    int alpha = Color.alpha(baseColor);

    for (int i = 0; i < numStops; i++) {
        float x = i * 1f / (numStops - 1);
        float opacity = constrain(0, 1, (float) Math.pow(x, 3));
        stopColors[i] = Color.argb((int) (alpha * opacity), red, green, blue);
    }

    final float x0, x1, y0, y1;
    switch (gravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
    case Gravity.LEFT:
        x0 = 1;
        x1 = 0;
        break;
    case Gravity.RIGHT:
        x0 = 0;
        x1 = 1;
        break;
    default:
        x0 = 0;
        x1 = 0;
        break;
    }
    switch (gravity & Gravity.VERTICAL_GRAVITY_MASK) {
    case Gravity.TOP:
        y0 = 1;
        y1 = 0;
        break;
    case Gravity.BOTTOM:
        y0 = 0;
        y1 = 1;
        break;
    default:
        y0 = 0;
        y1 = 0;
        break;
    }

    paintDrawable.setShaderFactory(new ShapeDrawable.ShaderFactory() {
        @Override
        public Shader resize(int width, int height) {
            LinearGradient linearGradient = new LinearGradient(width * x0, height * y0, width * x1, height * y1,
                    stopColors, null, Shader.TileMode.CLAMP);
            return linearGradient;
        }
    });

    cubicGradientScrimCache.put(cacheKeyHash, paintDrawable);
    return paintDrawable;
}

---

From source file:Main.java

/**
 * Creates a copy of the bitmap by calculating the transformation based on the 
 * original color and applying it to the the destination color.
 * @param bitmap The original bitmap./* w  ww.j  a va2  s . c o m*/
 * @param originalColor Tint color in the original bitmap.
 * @param destinationColor Tint color to be applied.
 * @return A copy of the given bitmap with the tint color changed.
 */
public static Bitmap changeTintColor(Bitmap bitmap, int originalColor, int destinationColor) {
    // original tint color
    int[] o = new int[] { Color.red(originalColor), Color.green(originalColor), Color.blue(originalColor) };
    // destination tint color
    int[] d = new int[] { Color.red(destinationColor), Color.green(destinationColor),
            Color.blue(destinationColor) };

    int width = bitmap.getWidth();
    int height = bitmap.getHeight();
    int[] pixels = new int[width * height];
    bitmap.getPixels(pixels, 0, width, 0, 0, width, height);

    int maxIndex = getMaxIndex(o);
    int mintIndex = getMinIndex(o);

    for (int i = 0; i < pixels.length; i++) {
        int color = pixels[i];
        // pixel color
        int[] p = new int[] { Color.red(color), Color.green(color), Color.blue(color) };
        int alpha = Color.alpha(color);

        float[] transformation = calculateTransformation(o[maxIndex], o[mintIndex], p[maxIndex], p[mintIndex]);
        pixels[i] = applyTransformation(d, alpha, transformation);
    }
    return Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
}

---

From source file:Main.java

/**
 * Creates an approximated cubic gradient using a multi-stop linear gradient. See
 * <a href="https://plus.google.com/+RomanNurik/posts/2QvHVFWrHZf">this post</a> for more
 * details.//from  www . ja  v a 2  s .  c  o m
 */
public static Drawable makeCubicGradientScrimDrawable(int baseColor, int numStops, int gravity) {
    numStops = Math.max(numStops, 2);

    PaintDrawable paintDrawable = new PaintDrawable();
    paintDrawable.setShape(new RectShape());

    final int[] stopColors = new int[numStops];

    int red = Color.red(baseColor);
    int green = Color.green(baseColor);
    int blue = Color.blue(baseColor);
    int alpha = Color.alpha(baseColor);

    for (int i = 0; i < numStops; i++) {
        float x = i * 1f / (numStops - 1);

        float opacity = (float) Math.max(0, Math.min(1, Math.pow(x, 3)));
        stopColors[i] = Color.argb((int) (alpha * opacity), red, green, blue);
    }

    final float x0, x1, y0, y1;
    switch (gravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
    case Gravity.LEFT:
        x0 = 1;
        x1 = 0;
        break;
    case Gravity.RIGHT:
        x0 = 0;
        x1 = 1;
        break;
    default:
        x0 = 0;
        x1 = 0;
        break;
    }
    switch (gravity & Gravity.VERTICAL_GRAVITY_MASK) {
    case Gravity.TOP:
        y0 = 1;
        y1 = 0;
        break;
    case Gravity.BOTTOM:
        y0 = 0;
        y1 = 1;
        break;
    default:
        y0 = 0;
        y1 = 0;
        break;
    }

    paintDrawable.setShaderFactory(new ShapeDrawable.ShaderFactory() {
        @Override
        public Shader resize(int width, int height) {
            LinearGradient linearGradient = new LinearGradient(width * x0, height * y0, width * x1, height * y1,
                    stopColors, null, Shader.TileMode.CLAMP);
            return linearGradient;
        }
    });

    return paintDrawable;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• »