| /******************************************************************************* |
| * Copyright (c) 2011 Laurent CARON |
| * 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: |
| * Laurent CARON (laurent.caron at gmail dot com) - initial API and implementation |
| *******************************************************************************/ |
| package org.mihalis.opal.brushedMetalComposite; |
| |
| import java.util.Random; |
| |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.SWTException; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.ImageData; |
| import org.eclipse.swt.graphics.PaletteData; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Widget; |
| import org.mihalis.opal.utils.SWTGraphicUtil; |
| |
| /** |
| * Instances of this class are controls which background's texture is brushed |
| * metal "a la Mac" |
| * This work is inspired by the article "Creating a brushed metal texture" by Jerry Huxtable (http://www.jhlabs.com/ip/brushed_metal.html) |
| */ |
| public class BrushedMetalComposite extends Composite { |
| |
| /** The old image. */ |
| private Image oldImage; |
| |
| /** The radius. */ |
| private int radius = 10; |
| |
| /** The amount. */ |
| private float amount = 0.1f; |
| |
| /** The color. */ |
| private int color = 0xff888888; |
| |
| /** The shine. */ |
| private float shine = 0.1f; |
| |
| /** The monochrome. */ |
| private boolean monochrome = true; |
| |
| /** The random numbers. */ |
| private Random randomNumbers; |
| |
| /** The palette. */ |
| private final PaletteData palette = new PaletteData(0xFF0000, 0x00FF00, 0x0000FF); |
| |
| /** The image data. */ |
| private ImageData imageData; |
| |
| /** |
| * Constructs a new instance of this class given its parent and a style |
| * value describing its behavior and appearance. |
| * <p> |
| * The style value is either one of the style constants defined in class |
| * <code>SWT</code> which is applicable to instances of this class, or must |
| * be built by <em>bitwise OR</em>'ing together (that is, using the |
| * <code>int</code> "|" operator) two or more of those <code>SWT</code> |
| * style constants. The class description lists the style constants that are |
| * applicable to the class. Style bits are also inherited from superclasses. |
| * </p> |
| * |
| * @param parent a widget which will be the parent of the new instance |
| * (cannot be null) |
| * @param style the style of widget to construct |
| * @see Composite#Composite(Composite, int) |
| * @see SWT#NO_BACKGROUND |
| * @see SWT#NO_FOCUS |
| * @see SWT#NO_MERGE_PAINTS |
| * @see SWT#NO_REDRAW_RESIZE |
| * @see SWT#NO_RADIO_GROUP |
| * @see SWT#EMBEDDED |
| * @see SWT#DOUBLE_BUFFERED |
| * @see Widget#getStyle |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> |
| * </ul> |
| * @exception SWTException <ul> |
| * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the |
| * thread that created the parent</li> |
| * </ul> |
| */ |
| public BrushedMetalComposite(final Composite parent, final int style) { |
| super(parent, style); |
| addListeners(parent); |
| } |
| |
| /** |
| * Adds the listeners. |
| * |
| * @param parent the parent |
| */ |
| private void addListeners(final Composite parent) { |
| this.addListener(SWT.Resize, new Listener() { |
| @Override |
| public void handleEvent(final Event event) { |
| createBrushedMetalBackground(); |
| paintControl(); |
| } |
| }); |
| |
| parent.addDisposeListener(new DisposeListener() { |
| @Override |
| public void widgetDisposed(final DisposeEvent e) { |
| SWTGraphicUtil.safeDispose(BrushedMetalComposite.this.oldImage); |
| } |
| }); |
| } |
| |
| /** |
| * Paint the component. |
| */ |
| private void paintControl() { |
| final Display display = getDisplay(); |
| final Image newImage = new Image(display, this.imageData); |
| |
| setBackgroundImage(newImage); |
| SWTGraphicUtil.safeDispose(this.oldImage); |
| this.oldImage = newImage; |
| } |
| |
| /** |
| * Create a brushed metal background. |
| * |
| * @return an image data that contains the background |
| */ |
| private void createBrushedMetalBackground() { |
| |
| final Rectangle rect = getClientArea(); |
| final int width = Math.max(1, rect.width); |
| final int height = Math.max(1, rect.width); |
| |
| final int[] inPixels = new int[width]; |
| |
| this.imageData = new ImageData(width, height, 0x20, this.palette); |
| |
| this.randomNumbers = new Random(0); |
| final int a = this.color & 0xff000000; |
| final int r = this.color >> 16 & 0xff; |
| final int g = this.color >> 8 & 0xff; |
| final int b = this.color & 0xff; |
| for (int y = 0; y < height; y++) { |
| for (int x = 0; x < width; x++) { |
| int tr = r; |
| int tg = g; |
| int tb = b; |
| if ( Float.compare( this.shine, (float) 0.0 ) != 0 ) { |
| final int f = (int) (255 * this.shine * Math.sin((double) x / width * Math.PI)); |
| tr += f; |
| tg += f; |
| tb += f; |
| } |
| if (this.monochrome) { |
| final int n = (int) (255 * (2 * this.randomNumbers.nextFloat() - 1) * this.amount); |
| inPixels[x] = a | this.clamp(tr + n) << 16 | this.clamp(tg + n) << 8 | this.clamp(tb + n); |
| } else { |
| inPixels[x] = a | this.random(tr) << 16 | this.random(tg) << 8 | this.random(tb); |
| } |
| } |
| |
| if (this.radius != 0) { |
| setDataElements(0, y, width, 1, this.blur(inPixels, width, this.radius)); |
| } else { |
| setDataElements(0, y, width, 1, inPixels); |
| } |
| } |
| |
| } |
| |
| /** |
| * Sets the data for a rectangle of pixels from a primitive array. |
| * |
| * @param posX The X coordinate of the upper left pixel location. |
| * @param posY The Y coordinate of the upper left pixel location. |
| * @param width Width of the pixel rectangle. |
| * @param height Height of the pixel rectangle |
| * @param pixels An array containing the pixel data to place between x,y and |
| * x+w-1, y+h-1. |
| */ |
| private void setDataElements(final int posX, final int posY, final int width, final int height, final int[] pixels) { |
| int cpt = 0; |
| for (int y = posY; y < posY + height; y++) { |
| for (int x = posX; x < posX + width; x++) { |
| final int rgb = pixels[cpt++]; |
| final int pixel = this.palette.getPixel(new RGB(rgb >> 16 & 0xFF, rgb >> 8 & 0xFF, rgb & 0xFF)); |
| this.imageData.setPixel(x, y, pixel); |
| this.imageData.setAlpha(x, y, rgb >> 24 & 0xFF); |
| } |
| } |
| } |
| |
| /** |
| * Add a random number to the value. The result is between 0 and 255 |
| * |
| * @param x the initial value |
| * @return the int |
| */ |
| private int random(int x) { |
| x += (int) (255 * (2 * this.randomNumbers.nextFloat() - 1) * this.amount); |
| if (x < 0) { |
| x = 0; |
| } else if (x > 0xff) { |
| x = 0xff; |
| } |
| return x; |
| } |
| |
| /** |
| * Clamp a number between 0 and 255. |
| * |
| * @param c the number to clamp |
| * @return the number. If c is negative, returns 0. If c is greater than |
| * 255, returns 255. |
| */ |
| private int clamp(final int c) { |
| if (c < 0) { |
| return 0; |
| } |
| |
| if (c > 255) { |
| return 255; |
| } |
| |
| return c; |
| } |
| |
| /** |
| * Apply a blur filter to an array of int that represents and image which |
| * size is width columns * 1 row. |
| * |
| * @param in the array of int that represents the image |
| * @param width the width of the image |
| * @param radius the "radius" blur parameter |
| * @return the int[] |
| */ |
| private int[] blur(final int[] in, final int width, final int radius) { |
| final int[] out = new int[width]; |
| final int widthMinus1 = width - 1; |
| final int r2 = 2 * radius + 1; |
| int tr = 0, tg = 0, tb = 0; |
| |
| for (int i = -radius; i <= radius; i++) { |
| final int rgb = in[this.mod(i, width)]; |
| tr += rgb >> 16 & 0xff; |
| tg += rgb >> 8 & 0xff; |
| tb += rgb & 0xff; |
| } |
| |
| for (int x = 0; x < width; x++) { |
| out[x] = 0xff000000 | tr / r2 << 16 | tg / r2 << 8 | tb / r2; |
| |
| int i1 = x + radius + 1; |
| if (i1 > widthMinus1) { |
| i1 = this.mod(i1, width); |
| } |
| int i2 = x - radius; |
| if (i2 < 0) { |
| i2 = this.mod(i2, width); |
| } |
| final int rgb1 = in[i1]; |
| final int rgb2 = in[i2]; |
| |
| tr += (rgb1 & 0xff0000) - (rgb2 & 0xff0000) >> 16; |
| tg += (rgb1 & 0xff00) - (rgb2 & 0xff00) >> 8; |
| tb += (rgb1 & 0xff) - (rgb2 & 0xff); |
| } |
| return out; |
| } |
| |
| /** |
| * Return a mod b. This differs from the % operator with respect to negative |
| * numbers. |
| * |
| * @param a the dividend |
| * @param b the divisor |
| * @return a mod b |
| */ |
| private int mod(int a, final int b) { |
| final int n = a / b; |
| |
| a -= n * b; |
| if (a < 0) { |
| return a + b; |
| } |
| return a; |
| } |
| |
| // ------------------------------------ Getters and Setters |
| |
| /** |
| * Gets the radius. |
| * |
| * @return the "radius" of the blur |
| */ |
| public int getRadius() { |
| return this.radius; |
| } |
| |
| /** |
| * Sets the radius. |
| * |
| * @param radius the "radius" of the blur |
| */ |
| public void setRadius(final int radius) { |
| this.radius = radius; |
| createBrushedMetalBackground(); |
| paintControl(); |
| } |
| |
| /** |
| * Gets the amount. |
| * |
| * @return the amount of noise to add |
| */ |
| public float getAmount() { |
| return this.amount; |
| } |
| |
| /** |
| * Sets the amount. |
| * |
| * @param amount the amount of noise to add |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_INVALID_ARGUMENT - if the value is not between 0 |
| * and 1 inclusive</li> |
| * </ul> |
| */ |
| public void setAmount(final float amount) { |
| if (amount < 0f || amount > 1f) { |
| SWT.error(SWT.ERROR_INVALID_ARGUMENT); |
| } |
| this.amount = amount; |
| createBrushedMetalBackground(); |
| paintControl(); |
| } |
| |
| /** |
| * Gets the color. |
| * |
| * @return the color of the metal. Please notice that this color is a new |
| * SWT object, so it has to be disposed ! |
| */ |
| public Color getColor() { |
| return new Color(this.getDisplay(), this.color >> 16 & 0xFF, this.color >> 8 & 0xFF, this.color & 0xFF); |
| } |
| |
| /** |
| * Sets the color. |
| * |
| * @param color the color to set |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the value is null</li> |
| * </ul> |
| */ |
| public void setColor(final Color color) { |
| if (color == null) { |
| SWT.error(SWT.ERROR_NULL_ARGUMENT); |
| return; // to satisfy SONAR |
| } |
| this.color = 0xFF << 24 | color.getRed() << 16 | color.getGreen() << 8 | color.getBlue(); |
| createBrushedMetalBackground(); |
| ; |
| paintControl(); |
| } |
| |
| /** |
| * Gets the shine. |
| * |
| * @return the shine to add |
| */ |
| public float getShine() { |
| return this.shine; |
| } |
| |
| /** |
| * Sets the shine. |
| * |
| * @param shine the shine to set |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_INVALID_ARGUMENT - if the value is not between 0 |
| * and 1 inclusive</li> |
| * </ul> |
| */ |
| public void setShine(final float shine) { |
| if (this.amount < 0f || this.amount > 1f) { |
| SWT.error(SWT.ERROR_INVALID_ARGUMENT); |
| } |
| this.shine = shine; |
| createBrushedMetalBackground(); |
| paintControl(); |
| } |
| |
| /** |
| * Checks if is monochrome. |
| * |
| * @return the monochrome |
| */ |
| public boolean isMonochrome() { |
| return this.monochrome; |
| } |
| |
| /** |
| * Sets the monochrome. |
| * |
| * @param monochrome the monochrome to set |
| */ |
| public void setMonochrome(final boolean monochrome) { |
| this.monochrome = monochrome; |
| createBrushedMetalBackground(); |
| paintControl(); |
| } |
| |
| } |