/*******************************************************************************
* Copyright (c) 2004, 2007 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.themes;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import org.eclipse.jface.resource.DataFormatException;
import org.eclipse.jface.resource.StringConverter;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.widgets.Display;
/**
* Useful color utilities.
*
* @since 3.0 - initial release
* @since 3.2 - public API
*/
public final class ColorUtil {
private static Field[] cachedFields;
/**
* Process the given string and return a corresponding RGB object.
*
* @param value
* the SWT constant <code>String</code>
* @return the value of the SWT constant, or <code>SWT.COLOR_BLACK</code>
* if it could not be determined
*/
private static RGB process(String value) {
Field [] fields = getFields();
try {
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
if (field.getName().equals(value)) {
return getSystemColor(field.getInt(null));
}
}
} catch (IllegalArgumentException e) {
// no op - shouldnt happen. We check for static before calling
// getInt(null)
} catch (IllegalAccessException e) {
// no op - shouldnt happen. We check for public before calling
// getInt(null)
}
return getSystemColor(SWT.COLOR_BLACK);
}
/**
* Get the SWT constant fields.
*
* @return the fields
* @since 3.3
*/
private static Field[] getFields() {
if (cachedFields == null) {
Class clazz = SWT.class;
Field[] allFields = clazz.getDeclaredFields();
ArrayList applicableFields = new ArrayList(allFields.length);
for (int i = 0; i < allFields.length; i++) {
Field field = allFields[i];
if (field.getType() == Integer.TYPE
&& Modifier.isStatic(field.getModifiers())
&& Modifier.isPublic(field.getModifiers())
&& Modifier.isFinal(field.getModifiers())
&& field.getName().startsWith("COLOR")) { //$NON-NLS-1$
applicableFields.add(field);
}
}
cachedFields = (Field []) applicableFields.toArray(new Field [applicableFields.size()]);
}
return cachedFields;
}
/**
* Blends the two color values according to the provided ratio.
*
* @param c1
* first color
* @param c2
* second color
* @param ratio
* percentage of the first color in the blend (0-100)
* @return the RGB value of the blended color
*
* @since 3.3
*/
public static RGB blend(RGB c1, RGB c2, int ratio) {
int r = blend(c1.red, c2.red, ratio);
int g = blend(c1.green, c2.green, ratio);
int b = blend(c1.blue, c2.blue, ratio);
return new RGB(r, g, b);
}
private static int blend(int v1, int v2, int ratio) {
int b = (ratio * v1 + (100 - ratio) * v2) / 100;
return Math.min(255, b);
}
/**
* Blend the two color values returning a value that is halfway between
* them.
*
* @param val1
* the first value
* @param val2
* the second value
* @return the blended color
*/
public static RGB blend(RGB val1, RGB val2) {
int red = blend(val1.red, val2.red);
int green = blend(val1.green, val2.green);
int blue = blend(val1.blue, val2.blue);
return new RGB(red, green, blue);
}
/**
* Blend the two color values returning a value that is halfway between
* them.
*
* @param temp1
* the first value
* @param temp2
* the second value
* @return the blended int value
*/
private static int blend(int temp1, int temp2) {
return (Math.abs(temp1 - temp2) / 2) + Math.min(temp1, temp2);
}
/**
* Return the system color that matches the provided SWT constant value.
*
* @param colorId
* the system color identifier
* @return the RGB value of the supplied system color
*/
private static RGB getSystemColor(int colorId) {
return Display.getCurrent().getSystemColor(colorId).getRGB();
}
/**
* Get the RGB value for a given color.
*
* @param rawValue
* the raw value, either an RGB triple or an SWT constant name
* @return the RGB value
* @throws DataFormatException
* thrown if the value cannot be interpreted as a color
*/
public static RGB getColorValue(String rawValue) throws DataFormatException {
if (rawValue == null) {
return null;
}
rawValue = rawValue.trim();
if (!isDirectValue(rawValue)) {
return process(rawValue);
}
return StringConverter.asRGB(rawValue);
}
/**
* Get the RGB values for a given color array.
*
* @param rawValues
* the raw values, either RGB triple or an SWT constant
* @return the RGB values
*/
public static RGB[] getColorValues(String[] rawValues) {
RGB[] values = new RGB[rawValues.length];
for (int i = 0; i < rawValues.length; i++) {
values[i] = getColorValue(rawValues[i]);
}
return values;
}
/**
* Return whether the value returned by <code>getValue()</code> is already
* in RGB form.
*
* @return whether the value returned by <code>getValue()</code> is
* already in RGB form
*/
private static boolean isDirectValue(String rawValue) {
return rawValue.indexOf(',') >= 0;
}
/**
* Not intended to be instantiated.
*/
private ColorUtil() {
// no-op
}
}