/*
 *  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.
 * 
 * @since Android 1.0
 */
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 the 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 the 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$
        }
    }

}