| /* |
| * 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 Igor V. Stolyarov |
| * @version $Revision$ |
| */ |
| package java.awt; |
| |
| import java.awt.Composite; |
| import java.awt.CompositeContext; |
| import java.awt.RenderingHints; |
| import java.awt.image.ColorModel; |
| |
| import org.apache.harmony.awt.gl.ICompositeContext; |
| import org.apache.harmony.awt.internal.nls.Messages; |
| |
| |
| /** |
| * The AlphaComposite class defines a basic alpha compositing rules for |
| * combining source and destination colors to achieve blending and |
| * transparency effects with graphics and images. |
| */ |
| public final class AlphaComposite implements Composite { |
| |
| /** |
| * The Constant CLEAR indicates that both the color and the alpha of |
| * the destination are cleared (Porter-Duff Clear rule). |
| */ |
| public static final int CLEAR = 1; |
| |
| /** |
| * The Constant SRC indicates that the source is copied to the destination |
| * (Porter-Duff Source rule). |
| */ |
| public static final int SRC = 2; |
| |
| /** The Constant DST indicates that the destination is left untouched |
| * (Porter-Duff Destination rule). |
| */ |
| public static final int DST = 9; |
| |
| /** |
| * The Constant SRC_OVER indicates that the source is composited over |
| * the destination (Porter-Duff Source Over Destination rule). |
| */ |
| public static final int SRC_OVER = 3; |
| |
| /** |
| * The Constant DST_OVER indicates that The destination is composited over |
| * the source and the result replaces the destination |
| * (Porter-Duff Destination Over Source rule). |
| */ |
| public static final int DST_OVER = 4; |
| |
| /** |
| * The Constant SRC_IN indicates that the part of the source lying |
| * inside of the destination replaces the destination (Porter-Duff |
| * Source In Destination rule). |
| */ |
| public static final int SRC_IN = 5; |
| |
| /** |
| * The Constant DST_IN indicates that the part of the destination |
| * lying inside of the source replaces the destination |
| * (Porter-Duff Destination In Source rule). |
| */ |
| public static final int DST_IN = 6; |
| |
| /** |
| * The Constant SRC_OUT indicates that the part of the source lying |
| * outside of the destination replaces the destination (Porter-Duff |
| * Source Held Out By Destination rule). |
| */ |
| public static final int SRC_OUT = 7; |
| |
| /** |
| * The Constant DST_OUT indicates that the part of the destination |
| * lying outside of the source replaces the destination (Porter-Duff |
| * Destination Held Out By Source rule). |
| */ |
| public static final int DST_OUT = 8; |
| |
| /** |
| * The Constant SRC_ATOP indicates that the part of the source lying |
| * inside of the destination is composited onto the destination |
| * (Porter-Duff Source Atop Destination rule). |
| */ |
| public static final int SRC_ATOP = 10; |
| |
| /** |
| * The Constant DST_ATOP indicates that the part of the destination |
| * lying inside of the source is composited over the source and replaces |
| * the destination (Porter-Duff Destination Atop Source rule). |
| */ |
| public static final int DST_ATOP = 11; |
| |
| /** |
| * The Constant XOR indicates that the part of the source that lies |
| * outside of the destination is combined with the part of the destination |
| * that lies outside of the source (Porter-Duff Source Xor Destination rule). |
| */ |
| public static final int XOR = 12; |
| |
| /** AlphaComposite object with the opaque CLEAR rule and an alpha of 1.0f. */ |
| public static final AlphaComposite Clear = new AlphaComposite(CLEAR); |
| |
| /** AlphaComposite object with the opaque SRC rule and an alpha of 1.0f. */ |
| public static final AlphaComposite Src = new AlphaComposite(SRC); |
| |
| /** AlphaComposite object with the opaque DST rule and an alpha of 1.0f. */ |
| public static final AlphaComposite Dst = new AlphaComposite(DST); |
| |
| /** AlphaComposite object with the opaque SRC_OVER rule and an alpha of 1.0f. */ |
| public static final AlphaComposite SrcOver = new AlphaComposite(SRC_OVER); |
| |
| /** AlphaComposite object with the opaque DST_OVER rule and an alpha of 1.0f. */ |
| public static final AlphaComposite DstOver = new AlphaComposite(DST_OVER); |
| |
| /** AlphaComposite object with the opaque SRC_IN rule and an alpha of 1.0f. */ |
| public static final AlphaComposite SrcIn = new AlphaComposite(SRC_IN); |
| |
| /** AlphaComposite object with the opaque DST_IN rule and an alpha of 1.0f. */ |
| public static final AlphaComposite DstIn = new AlphaComposite(DST_IN); |
| |
| /** AlphaComposite object with the opaque SRC_OUT rule and an alpha of 1.0f. */ |
| public static final AlphaComposite SrcOut = new AlphaComposite(SRC_OUT); |
| |
| /** AlphaComposite object with the opaque DST_OUT rule and an alpha of 1.0f. */ |
| public static final AlphaComposite DstOut = new AlphaComposite(DST_OUT); |
| |
| /** AlphaComposite object with the opaque SRC_ATOP rule and an alpha of 1.0f. */ |
| public static final AlphaComposite SrcAtop = new AlphaComposite(SRC_ATOP); |
| |
| /** AlphaComposite object with the opaque DST_ATOP rule and an alpha of 1.0f. */ |
| public static final AlphaComposite DstAtop = new AlphaComposite(DST_ATOP); |
| |
| /** AlphaComposite object with the opaque XOR rule and an alpha of 1.0f. */ |
| public static final AlphaComposite Xor = new AlphaComposite(XOR); |
| |
| /** The rule. */ |
| private int rule; |
| |
| /** The alpha. */ |
| private float alpha; |
| |
| /** |
| * Instantiates a new alpha composite. |
| * Creates a context for the compositing operation. The context contains state that is used in performing the compositing operation. |
| * |
| * @param rule the rule |
| * @param alpha the alpha |
| */ |
| private AlphaComposite(int rule, float alpha){ |
| if(rule < CLEAR || rule > XOR) { |
| // awt.11D=Unknown rule |
| throw new IllegalArgumentException(Messages.getString("awt.11D")); //$NON-NLS-1$ |
| } |
| if(alpha < 0.0f || alpha > 1.0f) { |
| // awt.11E=Wrong alpha value |
| throw new IllegalArgumentException(Messages.getString("awt.11E")); //$NON-NLS-1$ |
| } |
| |
| this.rule = rule; |
| this.alpha = alpha; |
| } |
| |
| /** |
| * Instantiates a new alpha composite. |
| * |
| * @param rule the rule |
| */ |
| private AlphaComposite(int rule){ |
| this(rule, 1.0f); |
| } |
| |
| /** |
| * Creates a CompositeContext object with the specified source ColorModel, |
| * destination ColorModel and RenderingHints parameters for a composing |
| * operation. |
| * |
| * @param srcColorModel the source's ColorModel. |
| * @param dstColorModel the destination's ColorModel. |
| * @param hints the RenderingHints object. |
| * |
| * @return the CompositeContext object. |
| * |
| * @see java.awt.Composite#createContext(java.awt.image.ColorModel, java.awt.image.ColorModel, java.awt.RenderingHints) |
| */ |
| public CompositeContext createContext(ColorModel srcColorModel, |
| ColorModel dstColorModel, RenderingHints hints) { |
| return new ICompositeContext(this, srcColorModel, dstColorModel); |
| } |
| |
| /** |
| * Compares the AlphaComposite object with the specified object. |
| * |
| * @param obj the Object to be compared. |
| * |
| * @return true, if the AlphaComposite object is equal to the specified |
| * object. |
| */ |
| @Override |
| public boolean equals(Object obj) { |
| if(!(obj instanceof AlphaComposite)) { |
| return false; |
| } |
| AlphaComposite other = (AlphaComposite)obj; |
| return (this.rule == other.getRule() && this.alpha == other.getAlpha()); |
| } |
| |
| /** |
| * Returns the hash code of the AlphaComposite object. |
| * |
| * @return the hash code of the AlphaComposite object. |
| */ |
| @Override |
| public int hashCode() { |
| int hash = Float.floatToIntBits(alpha); |
| int tmp = hash >>> 24; |
| hash <<= 8; |
| hash |= tmp; |
| hash ^= rule; |
| return hash; |
| } |
| |
| /** |
| * Gets the compositing rule of this AlphaComposite object. |
| * |
| * @return the compositing rule of this AlphaComposite object. |
| */ |
| public int getRule() { |
| return rule; |
| } |
| |
| /** |
| * Gets the alpha value of this AlphaComposite object; returns 1.0 if |
| * this AlphaComposite object doesn't have alpha value. |
| * |
| * @return the alpha value of this AlphaComposite object or 1.0 if |
| * this AlphaComposite object doesn't have alpha value. |
| */ |
| public float getAlpha() { |
| return alpha; |
| } |
| |
| /** |
| * Gets the AlphaComposite instance with the specified rule and alpha value. |
| * |
| * @param rule the compositing rule. |
| * @param alpha the alpha value. |
| * |
| * @return AlphaComposite instance. |
| */ |
| public static AlphaComposite getInstance(int rule, float alpha) { |
| if(alpha == 1.0f) { |
| return getInstance(rule); |
| } |
| return new AlphaComposite(rule, alpha); |
| } |
| |
| /** |
| * Gets the AlphaComposite instance with the specified rule. |
| * |
| * @param rule the compositing rule. |
| * |
| * @return AlphaComposite instance. |
| */ |
| public static AlphaComposite getInstance(int rule) { |
| switch(rule){ |
| case CLEAR: |
| return Clear; |
| case SRC: |
| return Src; |
| case DST: |
| return Dst; |
| case SRC_OVER: |
| return SrcOver; |
| case DST_OVER: |
| return DstOver; |
| case SRC_IN: |
| return SrcIn; |
| case DST_IN: |
| return DstIn; |
| case SRC_OUT: |
| return SrcOut; |
| case DST_OUT: |
| return DstOut; |
| case SRC_ATOP: |
| return SrcAtop; |
| case DST_ATOP: |
| return DstAtop; |
| case XOR: |
| return Xor; |
| default: |
| // awt.11D=Unknown rule |
| throw new IllegalArgumentException(Messages.getString("awt.11D")); //$NON-NLS-1$ |
| } |
| } |
| |
| } |
| |