plugins/org.eclipse.bpel.common.ui.noEmbeddedEditors/src/org/eclipse/bpel/common/ui/ColorUtils.java - bpel/org.eclipse.bpel - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005 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.bpel.common.ui;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.Color;
 import org.eclipse.swt.graphics.Device;
 import org.eclipse.swt.graphics.ImageData;
 import org.eclipse.swt.graphics.RGB;
 import org.eclipse.swt.widgets.Display;

 /**
  * General color utilities.
  */
 public final class ColorUtils {

 	/**
 	 * Gets a different color shade by changing its brightness
 	 * with the provided variation.
 	 */
 	public static Color getShade(Color original, float brightnessVariation, Display display) {
 		brightnessVariation  = isInvertedColorScheme() ? -brightnessVariation : brightnessVariation;
 		return new Color(display, getShadeRGB(original.getRGB(), brightnessVariation));
 	}

 	/**
 	 * Gets a different color shade by changing its brightness
 	 * with the provided variation.
 	 */
 	public static RGB getShadeRGB(RGB original, float brightnessVariation) {
 //		System.out.println("started " + original);
 		brightnessVariation  = isInvertedColorScheme() ? -brightnessVariation : brightnessVariation;
 		float[] hsb = RGBtoHSB(original.red, original.green, original.blue, null);
 		hsb[2] += brightnessVariation;
 		int rgb = HSBtoRGB(hsb[0], hsb[1], hsb[2]);
 //		System.out.println(new RGB(getRed(rgb), getGreen(rgb), getBlue(rgb)));
 		return new RGB(getRed(rgb), getGreen(rgb), getBlue(rgb));
 	}

 	/**
 	 * Returns an array of gradient colors from source to destination.
 	 * The source and destination colors are not included in the array.
 	 */
 	public static Color[] getColorShades(Color source, Color destination, int n, Display display) {
 		float interval = getBrightnessInterval(source.getRGB(), destination.getRGB());
 		interval = interval / (n+2);
 		Color[] result = new Color[n];
 		Color base = source;
 		for (int i = 0; i < result.length; i++) {
 			result[i] = getShade(base, interval, display);
 			base = result[i];
 		}
 		return result;
 	}

 	/**
 	 * Returns an array of gradient colors from source to destination.
 	 * The source and destination colors are not included in the array.
 	 */
 	public static float getBrightnessInterval(RGB source, RGB destination) {
 		float[] sourceHSB = RGBtoHSB(source.red, source.green, source.blue, null);
 		float[] destinationHSB = RGBtoHSB(destination.red, destination.green, destination.blue, null);
 		return (destinationHSB[2] - sourceHSB[2]);
 	}

 	/**
 	 * Returns an array of gradient colors from source to middle and from middle to destination.
 	 * The middle color is included but the source and destination are not.
 	 */
 	public static Color[] getColorShades(Color source, Color middle, Color destination, int n, Display display) {
 		Color[] result = new Color[n+1];
 		Color[] temp = getColorShades(source, middle, (n/2), display);
 		System.arraycopy(temp, 0, result, 0, temp.length);
 		int pos = temp.length;
 		result[pos] = new Color(display, middle.getRGB());
 		temp = getColorShades(middle, destination, (n - temp.length), display);
 		System.arraycopy(temp, 0, result, (pos+1), temp.length);
 		return result;
 	}

 	/**
 	 * Takes the source color and calculates the brightness interval with each
 	 * color of the shades array. Then creates a new color array based on the
 	 * destination color and the brightness intervals.
 	 */
 	public static RGB[] getColorShades(RGB source, RGB[] shades, RGB destination) {
 		RGB[] result = new RGB[shades.length];
 		for (int i = 0; i < shades.length; i++) {
 			RGB shade = shades[i];
 			float interval = getBrightnessInterval(source, shade);
 			result[i] = getShadeRGB(destination, interval);
 		}
 		return result;
 	}

 	/**
 	 * Converts the specified HSB values to a RBG value.
 	 *
 	 * @version 	initial
 	 *
 	 * @param	hue			the hue component
 	 * @param	saturation	the saturation component
 	 * @param	brightness	the brightness component
 	 *
 	 * @return	an <code>int</code> which is the converted RGB value
 	 */
 	public static int HSBtoRGB(float hue, float saturation, float brightness) {
 		float s = saturation;
 		float v = brightness;

 		int x = Math.round(v * 255);

 		if (s == 0) {
 			return 0xff000000 | (x << 16) | (x << 8) | x;
 		} else {
 			float h;
 			if (hue == 1.0f)
 				h = 0f;
 			else
 				h = (hue - (float)Math.floor(hue)) * 6.0f;

 			int i = (int)Math.floor(h);
 			float f = h - i;

 			int p = Math.round(255 * (v * (1 - s)));
 			int q = Math.round(255 * (v * (1 - (s * f))));
 			int t = Math.round(255 * (v * (1 - (s * (1 - f)))));
 			switch(i){
 				case 0: return 0xff000000 | (x << 16) | (t << 8) | p;
 				case 1: return 0xff000000 | (q << 16) | (x << 8) | p;
 				case 2: return 0xff000000 | (p << 16) | (x << 8) | t;
 				case 3: return 0xff000000 | (p << 16) | (q << 8) | x;
 				case 4: return 0xff000000 | (t << 16) | (p << 8) | x;
 				case 5: return 0xff000000 | (x << 16) | (p << 8) | q;
 				default: return 0;
 			}
 		}
 	}

 	/**
 	 * Fill and return the specified array with the specified RGB values
 	 * converted to HSB. Create, fill and return a new array if <code>null</code>
 	 * is passed in.
 	 * <p>
 	 * Color components must be in the range (0 - 255).
 	 *
 	 * @version 	initial
 	 *
 	 * @param	red		the red component
 	 * @param	green	the green component
 	 * @param	blue	the blue component
 	 * @param	hsb		the return value or <code>null</code>
 	 *
 	 * @return	an <code>float[]</code> containing the converted HSB values
 	 *
 	 * @throws	IllegalArgumentException	if any of the components are invalid
 	 */
 	public static float[] RGBtoHSB(int red, int green, int blue, float hsb[]) {
 		if ((red < 0 || red > 255) ||
 			(green < 0 || green > 255) ||
 			(blue < 0 || blue > 255))
 				throw new IllegalArgumentException();

 		float r = red / 255f;
 		float g = green / 255f;
 		float b = blue / 255f;

 		float h = 0; // hue
 		float s; // saturation
 		float v; // brightnees

 		float max = Math.max(r, Math.max(g, b));
 		float min = Math.min(r, Math.min(g, b));

 		// Calculate brightness
 		v = max;

 		// Calculate saturation
 		if (max != 0)
 			s = (max - min)/max;
 		else
 			s = 0;

 		// Calculate hue
 		if (s != 0) {
 			float delta = max - min;
 			if (r == max)
 				h = (g - b)/delta;
 			else if (g == max)
 				h = 2 + (b - r)/delta;
 			else if (b == max)
 				h = 4 + (r - g)/delta;

 			h = h * 60f;
 			if (h < 0)
 				h = h + 360f;
 			h /= 360f;
 		}

 		// Fill return value
 		if (hsb == null)
 			return new float[]{h, s, v};
 		else {
 			hsb[0] = h;
 			hsb[1] = s;
 			hsb[2] = v;
 			return hsb;
 		}
 	}

 	/**
 	 * Answers the blue component of the receiver.
 	 *
 	 * @version 	initial
 	 *
 	 * @return	an <code>int</code> which is the blue component of the receiver
 	 * 			in the range (0 - 255)
 	 *
 	 */
 	private static final int getBlue(int rgb) {
 		return rgb & 0xff;
 	}

 	/**
 	 * Answers the green component of the receiver.
 	 *
 	 * @version 	initial
 	 *
 	 * @return	an <code>int</code> which is the green component of the receiver
 	 * 			in the range (0 - 255)
 	 */
 	private static final int getGreen(int rgb) {
 		return (rgb & 0xff00) >> 8;
 	}

 	/**
 	 * Answers the red component of the receiver.
 	 *
 	 * @version 	initial
 	 *
 	 * @return	an <code>int</code> which is the red component of the receiver
 	 * 			in the range (0 - 255)
 	 */
 	private static final int getRed(int rgb) {
 		return (rgb & 0xff0000) >> 16;
 	}

 	/**
 	 * Replaces the given color in the image data.
 	 */
 	public static void replaceColor(ImageData data, RGB from, RGB to) {
 		for (int x = 0; x < data.width; x++) {
 			for (int y = 0; y < data.height; y++) {
 				int pixel = data.getPixel(x, y);
 				RGB rgb = data.palette.getRGB(pixel);
 				if (rgb.equals(from)) {
 					pixel = data.palette.getPixel(to);
 				}
 				data.setPixel(x, y, pixel);
 			}
 		}
 	}

 	/**
 	 *  scales the colors to be relative to the background and foreground colors (used to handle
 	 *  high contrast mode)
 	 *
 	 **/
 	public static Color getRelativeColor(Device device, int r, int g, int b) {
 		Color baseForeground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
 		Color baseBackground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
 		int fr = baseForeground.getRed();
 		int fg = baseForeground.getGreen();
 		int fb = baseForeground.getBlue();
 		int br = baseBackground.getRed();
 		int bg = baseBackground.getGreen();
 		int bb = baseBackground.getBlue();

 		int nr = (int) (fr + ((float)r * (br-fr) / 255));
 		int ng = (int) (fg + ((float)g * (bg-fg) / 255));
 		int nb = (int) (fb + ((float)b * (bb-fb) / 255));

 		// safety check, make sure all colors are in the correct range (in case we change the calculation above
 		nr = Math.max(0, nr);
 		nr = Math.min(255, nr);
 		ng = Math.max(0, ng);
 		ng = Math.min(255, ng);
 		nb = Math.max(0, nb);
 		nb = Math.min(255, nb);
 		return new Color(null, nr, ng, nb);
 	}

 	/**
 	 *  Scales the colors to be relative to the background and foreground colors (used to handle
 	 *  high contrast mode)
 	 */
 	public static RGB getRelativeRGB(int r, int g, int b) {
 		Color baseForeground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
 		Color baseBackground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
 		int fr = baseForeground.getRed();
 		int fg = baseForeground.getGreen();
 		int fb = baseForeground.getBlue();
 		int br = baseBackground.getRed();
 		int bg = baseBackground.getGreen();
 		int bb = baseBackground.getBlue();

 		int nr = (int) (fr + ((float)r * (br-fr) / 255));
 		int ng = (int) (fg + ((float)g * (bg-fg) / 255));
 		int nb = (int) (fb + ((float)b * (bb-fb) / 255));

 		// safety check, make sure all colors are in the correct range (in case we change the calculation above
 		nr = Math.max(0, nr);
 		nr = Math.min(255, nr);
 		ng = Math.max(0, ng);
 		ng = Math.min(255, ng);
 		nb = Math.max(0, nb);
 		nb = Math.min(255, nb);
 		return new RGB(nr, ng, nb);
 	}

 	public static Color getRelativeColor(Color c) {
 		Color cr = getRelativeColor(null, c.getRed(), c.getGreen(), c.getBlue());
 		c.dispose();
 		return cr;
 	}

 	public static Color getRelativeColorFromSystem(Color c) {
 		return getRelativeColor(null, c.getRed(), c.getGreen(), c.getBlue());
 	}

 	public static boolean isInvertedColorScheme() {
 		Color baseForeground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
 		Color baseBackground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND);

 		// normally, the foreground color is dark, compare the sums to see which one is "lighter"
 		if ((baseForeground.getRed() + baseForeground.getBlue() + baseForeground.getGreen()) >
 			(baseBackground.getRed() + baseBackground.getBlue() + baseBackground.getGreen())) {
 				return true;
 			}
 		return false;
 	}

 	public static RGB getLightShade(RGB rgb, int numerator, int denominator) {
 		int light = 255 * numerator;
 		int red = (rgb.red + light) / denominator;
 		int green = (rgb.green + light) / denominator;
 		int blue = (rgb.blue + light) / denominator;
 		return new RGB(red, green, blue);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005 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.bpel.common.ui;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.graphics.Color;
	import org.eclipse.swt.graphics.Device;
	import org.eclipse.swt.graphics.ImageData;
	import org.eclipse.swt.graphics.RGB;
	import org.eclipse.swt.widgets.Display;

	/**
	* General color utilities.
	*/
	public final class ColorUtils {

	/**
	* Gets a different color shade by changing its brightness
	* with the provided variation.
	*/
	public static Color getShade(Color original, float brightnessVariation, Display display) {
	brightnessVariation = isInvertedColorScheme() ? -brightnessVariation : brightnessVariation;
	return new Color(display, getShadeRGB(original.getRGB(), brightnessVariation));
	}

	/**
	* Gets a different color shade by changing its brightness
	* with the provided variation.
	*/
	public static RGB getShadeRGB(RGB original, float brightnessVariation) {
	// System.out.println("started " + original);
	brightnessVariation = isInvertedColorScheme() ? -brightnessVariation : brightnessVariation;
	float[] hsb = RGBtoHSB(original.red, original.green, original.blue, null);
	hsb[2] += brightnessVariation;
	int rgb = HSBtoRGB(hsb[0], hsb[1], hsb[2]);
	// System.out.println(new RGB(getRed(rgb), getGreen(rgb), getBlue(rgb)));
	return new RGB(getRed(rgb), getGreen(rgb), getBlue(rgb));
	}

	/**
	* Returns an array of gradient colors from source to destination.
	* The source and destination colors are not included in the array.
	*/
	public static Color[] getColorShades(Color source, Color destination, int n, Display display) {
	float interval = getBrightnessInterval(source.getRGB(), destination.getRGB());
	interval = interval / (n+2);
	Color[] result = new Color[n];
	Color base = source;
	for (int i = 0; i < result.length; i++) {
	result[i] = getShade(base, interval, display);
	base = result[i];
	}
	return result;
	}

	/**
	* Returns an array of gradient colors from source to destination.
	* The source and destination colors are not included in the array.
	*/
	public static float getBrightnessInterval(RGB source, RGB destination) {
	float[] sourceHSB = RGBtoHSB(source.red, source.green, source.blue, null);
	float[] destinationHSB = RGBtoHSB(destination.red, destination.green, destination.blue, null);
	return (destinationHSB[2] - sourceHSB[2]);
	}

	/**
	* Returns an array of gradient colors from source to middle and from middle to destination.
	* The middle color is included but the source and destination are not.
	*/
	public static Color[] getColorShades(Color source, Color middle, Color destination, int n, Display display) {
	Color[] result = new Color[n+1];
	Color[] temp = getColorShades(source, middle, (n/2), display);
	System.arraycopy(temp, 0, result, 0, temp.length);
	int pos = temp.length;
	result[pos] = new Color(display, middle.getRGB());
	temp = getColorShades(middle, destination, (n - temp.length), display);
	System.arraycopy(temp, 0, result, (pos+1), temp.length);
	return result;
	}

	/**
	* Takes the source color and calculates the brightness interval with each
	* color of the shades array. Then creates a new color array based on the
	* destination color and the brightness intervals.
	*/
	public static RGB[] getColorShades(RGB source, RGB[] shades, RGB destination) {
	RGB[] result = new RGB[shades.length];
	for (int i = 0; i < shades.length; i++) {
	RGB shade = shades[i];
	float interval = getBrightnessInterval(source, shade);
	result[i] = getShadeRGB(destination, interval);
	}
	return result;
	}

	/**
	* Converts the specified HSB values to a RBG value.
	*
	* @version initial
	*
	* @param hue the hue component
	* @param saturation the saturation component
	* @param brightness the brightness component
	*
	* @return an <code>int</code> which is the converted RGB value
	*/
	public static int HSBtoRGB(float hue, float saturation, float brightness) {
	float s = saturation;
	float v = brightness;

	int x = Math.round(v * 255);

	if (s == 0) {
	return 0xff000000 \| (x << 16) \| (x << 8) \| x;
	} else {
	float h;
	if (hue == 1.0f)
	h = 0f;
	else
	h = (hue - (float)Math.floor(hue)) * 6.0f;

	int i = (int)Math.floor(h);
	float f = h - i;

	int p = Math.round(255 * (v * (1 - s)));
	int q = Math.round(255 * (v * (1 - (s * f))));
	int t = Math.round(255 * (v * (1 - (s * (1 - f)))));
	switch(i){
	case 0: return 0xff000000 \| (x << 16) \| (t << 8) \| p;
	case 1: return 0xff000000 \| (q << 16) \| (x << 8) \| p;
	case 2: return 0xff000000 \| (p << 16) \| (x << 8) \| t;
	case 3: return 0xff000000 \| (p << 16) \| (q << 8) \| x;
	case 4: return 0xff000000 \| (t << 16) \| (p << 8) \| x;
	case 5: return 0xff000000 \| (x << 16) \| (p << 8) \| q;
	default: return 0;
	}
	}
	}

	/**
	* Fill and return the specified array with the specified RGB values
	* converted to HSB. Create, fill and return a new array if <code>null</code>
	* is passed in.
	* <p>
	* Color components must be in the range (0 - 255).
	*
	* @version initial
	*
	* @param red the red component
	* @param green the green component
	* @param blue the blue component
	* @param hsb the return value or <code>null</code>
	*
	* @return an <code>float[]</code> containing the converted HSB values
	*
	* @throws IllegalArgumentException if any of the components are invalid
	*/
	public static float[] RGBtoHSB(int red, int green, int blue, float hsb[]) {
	if ((red < 0 \|\| red > 255) \|\|
	(green < 0 \|\| green > 255) \|\|
	(blue < 0 \|\| blue > 255))
	throw new IllegalArgumentException();

	float r = red / 255f;
	float g = green / 255f;
	float b = blue / 255f;

	float h = 0; // hue
	float s; // saturation
	float v; // brightnees

	float max = Math.max(r, Math.max(g, b));
	float min = Math.min(r, Math.min(g, b));

	// Calculate brightness
	v = max;

	// Calculate saturation
	if (max != 0)
	s = (max - min)/max;
	else
	s = 0;

	// Calculate hue
	if (s != 0) {
	float delta = max - min;
	if (r == max)
	h = (g - b)/delta;
	else if (g == max)
	h = 2 + (b - r)/delta;
	else if (b == max)
	h = 4 + (r - g)/delta;

	h = h * 60f;
	if (h < 0)
	h = h + 360f;
	h /= 360f;
	}

	// Fill return value
	if (hsb == null)
	return new float[]{h, s, v};
	else {
	hsb[0] = h;
	hsb[1] = s;
	hsb[2] = v;
	return hsb;
	}
	}

	/**
	* Answers the blue component of the receiver.
	*
	* @version initial
	*
	* @return an <code>int</code> which is the blue component of the receiver
	* in the range (0 - 255)
	*
	*/
	private static final int getBlue(int rgb) {
	return rgb & 0xff;
	}

	/**
	* Answers the green component of the receiver.
	*
	* @version initial
	*
	* @return an <code>int</code> which is the green component of the receiver
	* in the range (0 - 255)
	*/
	private static final int getGreen(int rgb) {
	return (rgb & 0xff00) >> 8;
	}

	/**
	* Answers the red component of the receiver.
	*
	* @version initial
	*
	* @return an <code>int</code> which is the red component of the receiver
	* in the range (0 - 255)
	*/
	private static final int getRed(int rgb) {
	return (rgb & 0xff0000) >> 16;
	}

	/**
	* Replaces the given color in the image data.
	*/
	public static void replaceColor(ImageData data, RGB from, RGB to) {
	for (int x = 0; x < data.width; x++) {
	for (int y = 0; y < data.height; y++) {
	int pixel = data.getPixel(x, y);
	RGB rgb = data.palette.getRGB(pixel);
	if (rgb.equals(from)) {
	pixel = data.palette.getPixel(to);
	}
	data.setPixel(x, y, pixel);
	}
	}
	}

	/**
	* scales the colors to be relative to the background and foreground colors (used to handle
	* high contrast mode)
	*
	**/
	public static Color getRelativeColor(Device device, int r, int g, int b) {
	Color baseForeground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
	Color baseBackground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
	int fr = baseForeground.getRed();
	int fg = baseForeground.getGreen();
	int fb = baseForeground.getBlue();
	int br = baseBackground.getRed();
	int bg = baseBackground.getGreen();
	int bb = baseBackground.getBlue();

	int nr = (int) (fr + ((float)r * (br-fr) / 255));
	int ng = (int) (fg + ((float)g * (bg-fg) / 255));
	int nb = (int) (fb + ((float)b * (bb-fb) / 255));

	// safety check, make sure all colors are in the correct range (in case we change the calculation above
	nr = Math.max(0, nr);
	nr = Math.min(255, nr);
	ng = Math.max(0, ng);
	ng = Math.min(255, ng);
	nb = Math.max(0, nb);
	nb = Math.min(255, nb);
	return new Color(null, nr, ng, nb);
	}

	/**
	* Scales the colors to be relative to the background and foreground colors (used to handle
	* high contrast mode)
	*/
	public static RGB getRelativeRGB(int r, int g, int b) {
	Color baseForeground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
	Color baseBackground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND);
	int fr = baseForeground.getRed();
	int fg = baseForeground.getGreen();
	int fb = baseForeground.getBlue();
	int br = baseBackground.getRed();
	int bg = baseBackground.getGreen();
	int bb = baseBackground.getBlue();

	int nr = (int) (fr + ((float)r * (br-fr) / 255));
	int ng = (int) (fg + ((float)g * (bg-fg) / 255));
	int nb = (int) (fb + ((float)b * (bb-fb) / 255));

	// safety check, make sure all colors are in the correct range (in case we change the calculation above
	nr = Math.max(0, nr);
	nr = Math.min(255, nr);
	ng = Math.max(0, ng);
	ng = Math.min(255, ng);
	nb = Math.max(0, nb);
	nb = Math.min(255, nb);
	return new RGB(nr, ng, nb);
	}

	public static Color getRelativeColor(Color c) {
	Color cr = getRelativeColor(null, c.getRed(), c.getGreen(), c.getBlue());
	c.dispose();
	return cr;
	}

	public static Color getRelativeColorFromSystem(Color c) {
	return getRelativeColor(null, c.getRed(), c.getGreen(), c.getBlue());
	}

	public static boolean isInvertedColorScheme() {
	Color baseForeground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_FOREGROUND);
	Color baseBackground = Display.getCurrent().getSystemColor(SWT.COLOR_LIST_BACKGROUND);

	// normally, the foreground color is dark, compare the sums to see which one is "lighter"
	if ((baseForeground.getRed() + baseForeground.getBlue() + baseForeground.getGreen()) >
	(baseBackground.getRed() + baseBackground.getBlue() + baseBackground.getGreen())) {
	return true;
	}
	return false;
	}

	public static RGB getLightShade(RGB rgb, int numerator, int denominator) {
	int light = 255 * numerator;
	int red = (rgb.red + light) / denominator;
	int green = (rgb.green + light) / denominator;
	int blue = (rgb.blue + light) / denominator;
	return new RGB(red, green, blue);
	}
	}