/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Oleg V. Khaschansky
* @version $Revision$
*/
package java.awt;
import java.awt.color.ColorSpace;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.ColorModel;
import java.awt.image.DataBufferInt;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.io.Serializable;
import java.util.Arrays;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The Color class defines colors in the default sRGB color space or in the
* specified ColorSpace. Every Color contains alpha value. The alpha value
* defines the transparency of a color and can be represented by a float value
* in the range 0.0 - 1.0 or 0 - 255.
*
* @since Android 1.0
*/
public class Color implements Paint, Serializable {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = 118526816881161077L;
/*
* The values of the following colors are based on 1.5 release behavior
* which can be revealed using the following or similar code: Color c =
* Color.white; System.out.println(c);
*/
/**
* The color white.
*/
public static final Color white = new Color(255, 255, 255);
/**
* The color white.
*/
public static final Color WHITE = white;
/**
* The color light gray.
*/
public static final Color lightGray = new Color(192, 192, 192);
/**
* The color light gray.
*/
public static final Color LIGHT_GRAY = lightGray;
/**
* The color gray.
*/
public static final Color gray = new Color(128, 128, 128);
/**
* The color gray.
*/
public static final Color GRAY = gray;
/**
* The color dark gray.
*/
public static final Color darkGray = new Color(64, 64, 64);
/**
* The color dark gray.
*/
public static final Color DARK_GRAY = darkGray;
/**
* The color black.
*/
public static final Color black = new Color(0, 0, 0);
/**
* The color black.
*/
public static final Color BLACK = black;
/**
* The color red.
*/
public static final Color red = new Color(255, 0, 0);
/**
* The color red.
*/
public static final Color RED = red;
/**
* The color pink.
*/
public static final Color pink = new Color(255, 175, 175);
/**
* The color pink.
*/
public static final Color PINK = pink;
/**
* The color orange.
*/
public static final Color orange = new Color(255, 200, 0);
/**
* The color orange.
*/
public static final Color ORANGE = orange;
/**
* The color yellow.
*/
public static final Color yellow = new Color(255, 255, 0);
/**
* The color yellow.
*/
public static final Color YELLOW = yellow;
/**
* The color green.
*/
public static final Color green = new Color(0, 255, 0);
/**
* The color green.
*/
public static final Color GREEN = green;
/**
* The color magenta.
*/
public static final Color magenta = new Color(255, 0, 255);
/**
* The color magenta.
*/
public static final Color MAGENTA = magenta;
/**
* The color cyan.
*/
public static final Color cyan = new Color(0, 255, 255);
/**
* The color cyan.
*/
public static final Color CYAN = cyan;
/**
* The color blue.
*/
public static final Color blue = new Color(0, 0, 255);
/**
* The color blue.
*/
public static final Color BLUE = blue;
/**
* integer RGB value.
*/
int value;
/**
* Float sRGB value.
*/
private float[] frgbvalue;
/**
* Color in an arbitrary color space with <code>float</code> components. If
* null, other value should be used.
*/
private float fvalue[];
/**
* Float alpha value. If frgbvalue is null, this is not valid data.
*/
private float falpha;
/**
* The color's color space if applicable.
*/
private ColorSpace cs;
/*
* The value of the SCALE_FACTOR is based on 1.5 release behavior which can
* be revealed using the following code: Color c = new Color(100, 100, 100);
* Color bc = c.brighter(); System.out.println("Brighter factor: " +
* ((float)c.getRed())/((float)bc.getRed())); Color dc = c.darker();
* System.out.println("Darker factor: " +
* ((float)dc.getRed())/((float)c.getRed())); The result is the same for
* brighter and darker methods, so we need only one scale factor for both.
*/
/**
* The Constant SCALE_FACTOR.
*/
private static final double SCALE_FACTOR = 0.7;
/**
* The Constant MIN_SCALABLE.
*/
private static final int MIN_SCALABLE = 3; // should increase when
// multiplied by SCALE_FACTOR
/**
* The current paint context.
*/
transient private PaintContext currentPaintContext;
/**
* Creates a color in the specified ColorSpace, the specified color
* components and the specified alpha.
*
* @param cspace
* the ColorSpace to be used to define the components.
* @param components
* the components.
* @param alpha
* the alpha.
*/
public Color(ColorSpace cspace, float[] components, float alpha) {
int nComps = cspace.getNumComponents();
float comp;
fvalue = new float[nComps];
for (int i = 0; i < nComps; i++) {
comp = components[i];
if (comp < 0.0f || comp > 1.0f) {
// awt.107=Color parameter outside of expected range: component
// {0}.
throw new IllegalArgumentException(Messages.getString("awt.107", i)); //$NON-NLS-1$
}
fvalue[i] = components[i];
}
if (alpha < 0.0f || alpha > 1.0f) {
// awt.108=Alpha value outside of expected range.
throw new IllegalArgumentException(Messages.getString("awt.108")); //$NON-NLS-1$
}
falpha = alpha;
cs = cspace;
frgbvalue = cs.toRGB(fvalue);
value = ((int)(frgbvalue[2] * 255 + 0.5)) | (((int)(frgbvalue[1] * 255 + 0.5)) << 8)
| (((int)(frgbvalue[0] * 255 + 0.5)) << 16) | (((int)(falpha * 255 + 0.5)) << 24);
}
/**
* Instantiates a new sRGB color with the specified combined RGBA value
* consisting of the alpha component in bits 24-31, the red component in
* bits 16-23, the green component in bits 8-15, and the blue component in
* bits 0-7. If the hasalpha argument is false, the alpha has default value
* - 255.
*
* @param rgba
* the RGBA components.
* @param hasAlpha
* the alpha parameter is true if alpha bits are valid, false
* otherwise.
*/
public Color(int rgba, boolean hasAlpha) {
if (!hasAlpha) {
value = rgba | 0xFF000000;
} else {
value = rgba;
}
}
/**
* Instantiates a new color with the specified red, green, blue and alpha
* components.
*
* @param r
* the red component.
* @param g
* the green component.
* @param b
* the blue component.
* @param a
* the alpha component.
*/
public Color(int r, int g, int b, int a) {
if ((r & 0xFF) != r || (g & 0xFF) != g || (b & 0xFF) != b || (a & 0xFF) != a) {
// awt.109=Color parameter outside of expected range.
throw new IllegalArgumentException(Messages.getString("awt.109")); //$NON-NLS-1$
}
value = b | (g << 8) | (r << 16) | (a << 24);
}
/**
* Instantiates a new opaque sRGB color with the specified red, green, and
* blue values. The Alpha component is set to the default - 1.0.
*
* @param r
* the red component.
* @param g
* the green component.
* @param b
* the blue component.
*/
public Color(int r, int g, int b) {
if ((r & 0xFF) != r || (g & 0xFF) != g || (b & 0xFF) != b) {
// awt.109=Color parameter outside of expected range.
throw new IllegalArgumentException(Messages.getString("awt.109")); //$NON-NLS-1$
}
// 0xFF for alpha channel
value = b | (g << 8) | (r << 16) | 0xFF000000;
}
/**
* Instantiates a new sRGB color with the specified RGB value consisting of
* the red component in bits 16-23, the green component in bits 8-15, and
* the blue component in bits 0-7. Alpha has default value - 255.
*
* @param rgb
* the RGB components.
*/
public Color(int rgb) {
value = rgb | 0xFF000000;
}
/**
* Instantiates a new color with the specified red, green, blue and alpha
* components.
*
* @param r
* the red component.
* @param g
* the green component.
* @param b
* the blue component.
* @param a
* the alpha component.
*/
public Color(float r, float g, float b, float a) {
this((int)(r * 255 + 0.5), (int)(g * 255 + 0.5), (int)(b * 255 + 0.5), (int)(a * 255 + 0.5));
falpha = a;
fvalue = new float[3];
fvalue[0] = r;
fvalue[1] = g;
fvalue[2] = b;
frgbvalue = fvalue;
}
/**
* Instantiates a new color with the specified red, green, and blue
* components and default alpha value - 1.0.
*
* @param r
* the red component.
* @param g
* the green component.
* @param b
* the blue component.
*/
public Color(float r, float g, float b) {
this(r, g, b, 1.0f);
}
public PaintContext createContext(ColorModel cm, Rectangle r, Rectangle2D r2d,
AffineTransform xform, RenderingHints rhs) {
if (currentPaintContext != null) {
return currentPaintContext;
}
currentPaintContext = new Color.ColorPaintContext(value);
return currentPaintContext;
}
/**
* Returns a string representation of the Color object.
*
* @return the string representation of the Color object.
*/
@Override
public String toString() {
/*
* The format of the string is based on 1.5 release behavior which can
* be revealed using the following code: Color c = new Color(1, 2, 3);
* System.out.println(c);
*/
return getClass().getName() + "[r=" + getRed() + //$NON-NLS-1$
",g=" + getGreen() + //$NON-NLS-1$
",b=" + getBlue() + //$NON-NLS-1$
"]"; //$NON-NLS-1$
}
/**
* Compares the specified Object to the Color.
*
* @param obj
* the Object to be compared.
* @return true, if the specified Object is a Color whose value is equal to
* this Color, false otherwise.
*/
@Override
public boolean equals(Object obj) {
if (obj instanceof Color) {
return ((Color)obj).value == this.value;
}
return false;
}
/**
* Returns a float array containing the color and alpha components of the
* Color in the specified ColorSpace.
*
* @param colorSpace
* the specified ColorSpace.
* @param components
* the results of this method will be written to this float
* array. If null, a float array will be created.
* @return the color and alpha components in a float array.
*/
public float[] getComponents(ColorSpace colorSpace, float[] components) {
int nComps = colorSpace.getNumComponents();
if (components == null) {
components = new float[nComps + 1];
}
getColorComponents(colorSpace, components);
if (frgbvalue != null) {
components[nComps] = falpha;
} else {
components[nComps] = getAlpha() / 255f;
}
return components;
}
/**
* Returns a float array containing the color components of the Color in the
* specified ColorSpace.
*
* @param colorSpace
* the specified ColorSpace.
* @param components
* the results of this method will be written to this float
* array. If null, a float array will be created.
* @return the color components in a float array.
*/
public float[] getColorComponents(ColorSpace colorSpace, float[] components) {
float[] cieXYZComponents = getColorSpace().toCIEXYZ(getColorComponents(null));
float[] csComponents = colorSpace.fromCIEXYZ(cieXYZComponents);
if (components == null) {
return csComponents;
}
for (int i = 0; i < csComponents.length; i++) {
components[i] = csComponents[i];
}
return components;
}
/**
* Gets the ColorSpace of this Color.
*
* @return the ColorSpace object.
*/
public ColorSpace getColorSpace() {
if (cs == null) {
cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
}
return cs;
}
/**
* Creates a new Color which is a darker than this Color according to a
* fixed scale factor.
*
* @return the darker Color.
*/
public Color darker() {
return new Color((int)(getRed() * SCALE_FACTOR), (int)(getGreen() * SCALE_FACTOR),
(int)(getBlue() * SCALE_FACTOR));
}
/**
* Creates a new Color which is a brighter than this Color.
*
* @return the brighter Color.
*/
public Color brighter() {
int r = getRed();
int b = getBlue();
int g = getGreen();
if (r == 0 && b == 0 && g == 0) {
return new Color(MIN_SCALABLE, MIN_SCALABLE, MIN_SCALABLE);
}
if (r < MIN_SCALABLE && r != 0) {
r = MIN_SCALABLE;
} else {
r = (int)(r / SCALE_FACTOR);
r = (r > 255) ? 255 : r;
}
if (b < MIN_SCALABLE && b != 0) {
b = MIN_SCALABLE;
} else {
b = (int)(b / SCALE_FACTOR);
b = (b > 255) ? 255 : b;
}
if (g < MIN_SCALABLE && g != 0) {
g = MIN_SCALABLE;
} else {
g = (int)(g / SCALE_FACTOR);
g = (g > 255) ? 255 : g;
}
return new Color(r, g, b);
}
/**
* Returns a float array containing the color and alpha components of the
* Color in the default sRGB color space.
*
* @param components
* the results of this method will be written to this float
* array. A new float array will be created if this argument is
* null.
* @return the RGB color and alpha components in a float array.
*/
public float[] getRGBComponents(float[] components) {
if (components == null) {
components = new float[4];
}
if (frgbvalue != null) {
components[3] = falpha;
} else {
components[3] = getAlpha() / 255f;
}
getRGBColorComponents(components);
return components;
}
/**
* Returns a float array containing the color components of the Color in the
* default sRGB color space.
*
* @param components
* the results of this method will be written to this float
* array. A new float array will be created if this argument is
* null.
* @return the RGB color components in a float array.
*/
public float[] getRGBColorComponents(float[] components) {
if (components == null) {
components = new float[3];
}
if (frgbvalue != null) {
components[2] = frgbvalue[2];
components[1] = frgbvalue[1];
components[0] = frgbvalue[0];
} else {
components[2] = getBlue() / 255f;
components[1] = getGreen() / 255f;
components[0] = getRed() / 255f;
}
return components;
}
/**
* Returns a float array which contains the color and alpha components of
* the Color in the ColorSpace of the Color.
*
* @param components
* the results of this method will be written to this float
* array. A new float array will be created if this argument is
* null.
* @return the color and alpha components in a float array.
*/
public float[] getComponents(float[] components) {
if (fvalue == null) {
return getRGBComponents(components);
}
int nColorComps = fvalue.length;
if (components == null) {
components = new float[nColorComps + 1];
}
getColorComponents(components);
components[nColorComps] = falpha;
return components;
}
/**
* Returns a float array which contains the color components of the Color in
* the ColorSpace of the Color.
*
* @param components
* the results of this method will be written to this float
* array. A new float array will be created if this argument is
* null.
* @return the color components in a float array.
*/
public float[] getColorComponents(float[] components) {
if (fvalue == null) {
return getRGBColorComponents(components);
}
if (components == null) {
components = new float[fvalue.length];
}
for (int i = 0; i < fvalue.length; i++) {
components[i] = fvalue[i];
}
return components;
}
/**
* Returns a hash code of this Color object.
*
* @return a hash code of this Color object.
*/
@Override
public int hashCode() {
return value;
}
public int getTransparency() {
switch (getAlpha()) {
case 0xff:
return Transparency.OPAQUE;
case 0:
return Transparency.BITMASK;
default:
return Transparency.TRANSLUCENT;
}
}
/**
* Gets the red component of the Color in the range 0-255.
*
* @return the red component of the Color.
*/
public int getRed() {
return (value >> 16) & 0xFF;
}
/**
* Gets the RGB value that represents the color in the default sRGB
* ColorModel.
*
* @return the RGB color value in the default sRGB ColorModel.
*/
public int getRGB() {
return value;
}
/**
* Gets the green component of the Color in the range 0-255.
*
* @return the green component of the Color.
*/
public int getGreen() {
return (value >> 8) & 0xFF;
}
/**
* Gets the blue component of the Color in the range 0-255.
*
* @return the blue component of the Color.
*/
public int getBlue() {
return value & 0xFF;
}
/**
* Gets the alpha component of the Color in the range 0-255.
*
* @return the alpha component of the Color.
*/
public int getAlpha() {
return (value >> 24) & 0xFF;
}
/**
* Gets the Color from the specified string, or returns the Color specified
* by the second parameter.
*
* @param nm
* the specified string.
* @param def
* the default Color.
* @return the color from the specified string, or the Color specified by
* the second parameter.
*/
public static Color getColor(String nm, Color def) {
Integer integer = Integer.getInteger(nm);
if (integer == null) {
return def;
}
return new Color(integer.intValue());
}
/**
* Gets the Color from the specified string, or returns the Color converted
* from the second parameter.
*
* @param nm
* the specified string.
* @param def
* the default Color.
* @return the color from the specified string, or the Color converted from
* the second parameter.
*/
public static Color getColor(String nm, int def) {
Integer integer = Integer.getInteger(nm);
if (integer == null) {
return new Color(def);
}
return new Color(integer.intValue());
}
/**
* Gets the Color from the specified String.
*
* @param nm
* the specified string.
* @return the Color object, or null.
*/
public static Color getColor(String nm) {
Integer integer = Integer.getInteger(nm);
if (integer == null) {
return null;
}
return new Color(integer.intValue());
}
/**
* Decodes a String to an integer and returns the specified opaque Color.
*
* @param nm
* the String which represents an opaque color as a 24-bit
* integer.
* @return the Color object from the given String.
* @throws NumberFormatException
* if the specified string can not be converted to an integer.
*/
public static Color decode(String nm) throws NumberFormatException {
Integer integer = Integer.decode(nm);
return new Color(integer.intValue());
}
/**
* Gets a Color object using the specified values of the HSB color model.
*
* @param h
* the hue component of the Color.
* @param s
* the saturation of the Color.
* @param b
* the brightness of the Color.
* @return a color object with the specified hue, saturation and brightness
* values.
*/
public static Color getHSBColor(float h, float s, float b) {
return new Color(HSBtoRGB(h, s, b));
}
/**
* Converts the Color specified by the RGB model to an equivalent color in
* the HSB model.
*
* @param r
* the red component.
* @param g
* the green component.
* @param b
* the blue component.
* @param hsbvals
* the array of result hue, saturation, brightness values or
* null.
* @return the float array of hue, saturation, brightness values.
*/
public static float[] RGBtoHSB(int r, int g, int b, float[] hsbvals) {
if (hsbvals == null) {
hsbvals = new float[3];
}
int V = Math.max(b, Math.max(r, g));
int temp = Math.min(b, Math.min(r, g));
float H, S, B;
B = V / 255.f;
if (V == temp) {
H = S = 0;
} else {
S = (V - temp) / ((float)V);
float Cr = (V - r) / (float)(V - temp);
float Cg = (V - g) / (float)(V - temp);
float Cb = (V - b) / (float)(V - temp);
if (r == V) {
H = Cb - Cg;
} else if (g == V) {
H = 2 + Cr - Cb;
} else {
H = 4 + Cg - Cr;
}
H /= 6.f;
if (H < 0) {
H++;
}
}
hsbvals[0] = H;
hsbvals[1] = S;
hsbvals[2] = B;
return hsbvals;
}
/**
* Converts the Color specified by the HSB model to an equivalent color in
* the default RGB model.
*
* @param hue
* the hue component of the Color.
* @param saturation
* the saturation of the Color.
* @param brightness
* the brightness of the Color.
* @return the RGB value of the color with the specified hue, saturation and
* brightness.
*/
public static int HSBtoRGB(float hue, float saturation, float brightness) {
float fr, fg, fb;
if (saturation == 0) {
fr = fg = fb = brightness;
} else {
float H = (hue - (float)Math.floor(hue)) * 6;
int I = (int)Math.floor(H);
float F = H - I;
float M = brightness * (1 - saturation);
float N = brightness * (1 - saturation * F);
float K = brightness * (1 - saturation * (1 - F));
switch (I) {
case 0:
fr = brightness;
fg = K;
fb = M;
break;
case 1:
fr = N;
fg = brightness;
fb = M;
break;
case 2:
fr = M;
fg = brightness;
fb = K;
break;
case 3:
fr = M;
fg = N;
fb = brightness;
break;
case 4:
fr = K;
fg = M;
fb = brightness;
break;
case 5:
fr = brightness;
fg = M;
fb = N;
break;
default:
fr = fb = fg = 0; // impossible, to supress compiler error
}
}
int r = (int)(fr * 255. + 0.5);
int g = (int)(fg * 255. + 0.5);
int b = (int)(fb * 255. + 0.5);
return (r << 16) | (g << 8) | b | 0xFF000000;
}
/**
* The Class ColorPaintContext.
*/
class ColorPaintContext implements PaintContext {
/**
* The RGB value.
*/
int rgbValue;
/**
* The saved raster.
*/
WritableRaster savedRaster = null;
/**
* Instantiates a new color paint context.
*
* @param rgb
* the RGB value.
*/
protected ColorPaintContext(int rgb) {
rgbValue = rgb;
}
public void dispose() {
savedRaster = null;
}
public ColorModel getColorModel() {
return ColorModel.getRGBdefault();
}
public Raster getRaster(int x, int y, int w, int h) {
if (savedRaster == null || w != savedRaster.getWidth() || h != savedRaster.getHeight()) {
savedRaster = getColorModel().createCompatibleWritableRaster(w, h);
// Suppose we have here simple INT/RGB color/sample model
DataBufferInt intBuffer = (DataBufferInt)savedRaster.getDataBuffer();
int rgbValues[] = intBuffer.getData();
int rgbFillValue = rgbValue;
Arrays.fill(rgbValues, rgbFillValue);
}
return savedRaster;
}
}
}
|
