SWTUtil.java

/*
 * Copyright (c) 2008 Matthew Hall 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:
 *     Matthew Hall - initial API and implementation
 */
package org.eclipse.nebula.paperclips.core.internal.util;

import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.PaletteData;
import org.eclipse.swt.graphics.RGB;

/**
 * Utility methods for dealing with SWT objects
 * 
 * @author Matthew Hall
 */
public class SWTUtil {

	/**
	 * Returns a defensive copy of the passed in FontData.
	 * 
	 * @param fontData
	 *            the FontData to copy. May be null.
	 * @return a copy of the passed in FontData, or null if the argument was
	 *         null.
	 */
	public static FontData copy(FontData fontData) {
		return fontData == null ? null : new FontData(fontData.getName(),
				fontData.getHeight(), fontData.getStyle());
	}

	/**
	 * Returns a defensive copy of the passed in RGB.
	 * 
	 * @param rgb
	 *            the RGB to copy. May be null.
	 * @return a copy of the passed in RGB, or null if the argument was null.
	 */
	public static RGB copy(RGB rgb) {
		return rgb == null ? null : new RGB(rgb.red, rgb.green, rgb.blue);
	}

	/**
	 * Returns an RGB representing the color described by the argument.
	 * <p>
	 * Sample colors:<br>
	 * 0xFFFFFF: white<br>
	 * 0x000000: black<br>
	 * 0xFF0000: red<br>
	 * 0x00FF00: green<br>
	 * 0x0000FF: blue
	 * 
	 * @param rgb
	 *            an integer containing the red, green and blue components in
	 *            the 0xFF0000, 0x00FF00, and 0x0000FF positions, respectively.
	 * @return an RGB representing the color described by the argument.
	 */
	public static RGB deriveRGB(final int rgb) {
		int red = (rgb >> 16) & 0xFF;
		int green = (rgb >> 8) & 0xFF;
		int blue = rgb & 0xFF;
		return new RGB(red, green, blue);
	}

	/**
	 * Returns whether the PaletteData arguments are equivalent.
	 * 
	 * @param left
	 *            the left PaletteData
	 * @param right
	 *            the right PaletteData
	 * @return whether the PaletteData arguments are equivalent.
	 */
	public static boolean equal(PaletteData left, PaletteData right) {
		if (left == right)
			return true;
		if (left == null || right == null)
			return false;
		return left.isDirect == right.isDirect
				&& left.blueMask == right.blueMask
				&& left.blueShift == right.blueShift
				&& left.greenMask == right.greenMask
				&& left.greenShift == right.greenShift
				&& left.redMask == right.redMask
				&& left.redShift == right.redShift
				&& Util.equal(left.colors, right.colors);
	}

	/**
	 * Returns a hash code for the PaletteData.
	 * 
	 * @param data
	 *            the PaletteData
	 * @return a hash code for the PaletteData.
	 */
	public static int hashCode(PaletteData data) {
		final int prime = 31;
		int result = 1;
		result = prime * result + (data.isDirect ? 1231 : 1237);
		result = prime * result + data.blueMask;
		result = prime * result + data.blueShift;
		result = prime * result + data.greenMask;
		result = prime * result + data.greenShift;
		result = prime * result + data.redMask;
		result = prime * result + data.redShift;
		result = prime * result + hashCode(data.colors);
		return result;
	}

	private static int hashCode(Object[] array) {
		int prime = 31;
		if (array == null)
			return 0;
		int result = 1;
		for (int index = 0; index < array.length; index++) {
			result = prime * result
					+ (array[index] == null ? 0 : array[index].hashCode());
		}
		return result;
	}

	/**
	 * Returns whether the ImageData arguments are equivalent.
	 * 
	 * @param left
	 *            the left ImageData
	 * @param right
	 *            the right ImageData
	 * @return whether the ImageData arguments are equivalent.
	 */
	public static boolean equal(ImageData left, ImageData right) {
		if (left == right)
			return true;
		if (left == null || right == null)
			return false;
		if (left.width != right.width || left.height != right.height)
			return false;
		if (!equal(left.palette, right.palette))
			return false;

		final int width = left.width;
		int[] leftPixels = new int[width];
		int[] rightPixels = new int[width];
		byte[] leftAlphas = new byte[width];
		byte[] rightAlphas = new byte[width];
		for (int y = 0; y < left.height; y++) {
			left.getAlphas(0, y, width, leftAlphas, 0);
			right.getAlphas(0, y, width, rightAlphas, 0);
			if (!Util.equal(leftAlphas, rightAlphas))
				return false;

			left.getPixels(0, y, width, leftPixels, 0);
			right.getPixels(0, y, width, rightPixels, 0);
			if (!Util.equal(leftPixels, rightPixels)) {
				for (int x = 0; x < width; x++) {
					if (leftAlphas[x] != 0 && leftPixels[x] != rightPixels[x])
						return false;
				}
			}
		}

		return true;
	}

	/**
	 * Returns a hash code for the ImageData
	 * 
	 * @param data
	 *            the ImageData
	 * @return a hash code for the ImageData
	 */
	public static int hashCode(ImageData data) {
		final int prime = 31;
		int result = 1;
		result = prime * result + data.width;
		result = prime * result + data.height;
		result = prime * result + hashCode(data.palette);
		// Neglect pixel data
		return result;
	}
}