/*

 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.awt;

import java.awt.Component;

import java.awt.Graphics;

import java.awt.Rectangle;

import java.awt.event.PaintEvent;

/**

 * The <code>RepaintArea</code> is a geometric construct created for the

 * purpose of holding the geometry of several coalesced paint events.

 * This geometry is accessed synchronously, although it is written such

 * that painting may still be executed asynchronously.

 *

 * @author      Eric Hawkes

 * @since       1.3

 */

public class RepaintArea {

    /**

     * Maximum ratio of bounding rectangle to benefit for which

     * both the vertical and horizontal unions are repainted.

     * For smaller ratios the whole bounding rectangle is repainted.

     * @see #paint

     */

    private static final int MAX_BENEFIT_RATIO = 4;

    private static final int HORIZONTAL = 0;

    private static final int VERTICAL = 1;

    private static final int UPDATE = 2;

    private static final int RECT_COUNT = UPDATE + 1;

    private Rectangle paintRects[] = new Rectangle[RECT_COUNT];

    /**

     * Constructs a new <code>RepaintArea</code>

     * @since   1.3

     */

    public RepaintArea() {

    }

    /**

     * Constructs a new <code>RepaintArea</code> initialized to match

     * the values of the specified RepaintArea.

     *

     * @param   ra  the <code>RepaintArea</code> from which to copy initial

     *              values to a newly constructed RepaintArea

     * @since   1.3

     */

    private RepaintArea(RepaintArea ra) {

        // This constructor is private because it should only be called

        // from the cloneAndReset method

        for (int i = 0; i < RECT_COUNT; i++) {

            paintRects[i] = ra.paintRects[i];

        }

    }

    /**

     * Adds a <code>Rectangle</code> to this <code>RepaintArea</code>.

     * PAINT Rectangles are divided into mostly vertical and mostly horizontal.

     * Each group is unioned together.

     * UPDATE Rectangles are unioned.

     *

     * @param   r   the specified <code>Rectangle</code>

     * @param   id  possible values PaintEvent.UPDATE or PaintEvent.PAINT

     * @since   1.3

     */

    public synchronized void add(Rectangle r, int id) {

        // Make sure this new rectangle has positive dimensions

        if (r.isEmpty()) {

            return;

        }

        int addTo = UPDATE;

        if (id == PaintEvent.PAINT) {

            addTo = (r.width > r.height) ? HORIZONTAL : VERTICAL;

        }

        if (paintRects[addTo] != null) {

            paintRects[addTo].add(r);

        } else {

            paintRects[addTo] = new Rectangle(r);

        }

    }

    /**

     * Creates a new <code>RepaintArea</code> with the same geometry as this

     * RepaintArea, then removes all of the geometry from this

     * RepaintArea and restores it to an empty RepaintArea.

     *

     * @return  ra a new <code>RepaintArea</code> having the same geometry as

     *          this RepaintArea.

     * @since   1.3

     */

    private synchronized RepaintArea cloneAndReset() {

        RepaintArea ra = new RepaintArea(this);

        for (int i = 0; i < RECT_COUNT; i++) {

            paintRects[i] = null;

        }

        return ra;

    }

    public boolean isEmpty() {

        for (int i = 0; i < RECT_COUNT; i++) {

            if (paintRects[i] != null) {

                return false;

            }

        }

        return true;

    }

    /**

     * Constrains the size of the repaint area to the passed in bounds.

     */

    public synchronized void constrain(int x, int y, int w, int h) {

        for (int i = 0; i < RECT_COUNT; i++) {

            Rectangle rect = paintRects[i];

            if (rect != null) {

                if (rect.x < x) {

                    rect.width -= (x - rect.x);

                    rect.x = x;

                }

                if (rect.y < y) {

                    rect.height -= (y - rect.y);

                    rect.y = y;

                }

                int xDelta = rect.x + rect.width - x - w;

                if (xDelta > 0) {

                    rect.width -= xDelta;

                }

                int yDelta = rect.y + rect.height - y - h;

                if (yDelta > 0) {

                    rect.height -= yDelta;

                }

                if (rect.width <= 0 || rect.height <= 0) {

                    paintRects[i] = null;

                }

            }

        }

    }

    /**

     * Marks the passed in region as not needing to be painted. It's possible

     * this will do nothing.

     */

    public synchronized void subtract(int x, int y, int w, int h) {

        Rectangle subtract = new Rectangle(x, y, w, h);

        for (int i = 0; i < RECT_COUNT; i++) {

            if (subtract(paintRects[i], subtract)) {

                if (paintRects[i] != null && paintRects[i].isEmpty()) {

                    paintRects[i] = null;

                }

            }

        }

    }

    /**

     * Invokes paint and update on target Component with optimal

     * rectangular clip region.

     * If PAINT bounding rectangle is less than

     * MAX_BENEFIT_RATIO times the benefit, then the vertical and horizontal unions are

     * painted separately.  Otherwise the entire bounding rectangle is painted.

     *

     * @param   target Component to <code>paint</code> or <code>update</code>

     * @since   1.4

     */

    public void paint(Object target, boolean shouldClearRectBeforePaint) {

        Component comp = (Component)target;

        if (isEmpty()) {

            return;

        }

        if (!comp.isVisible()) {

            return;

        }

        RepaintArea ra = this.cloneAndReset();

        if (!subtract(ra.paintRects[VERTICAL], ra.paintRects[HORIZONTAL])) {

            subtract(ra.paintRects[HORIZONTAL], ra.paintRects[VERTICAL]);

        }

        if (ra.paintRects[HORIZONTAL] != null && ra.paintRects[VERTICAL] != null) {

            Rectangle paintRect = ra.paintRects[HORIZONTAL].union(ra.paintRects[VERTICAL]);

            int square = paintRect.width * paintRect.height;

            int benefit = square - ra.paintRects[HORIZONTAL].width

                * ra.paintRects[HORIZONTAL].height - ra.paintRects[VERTICAL].width

                * ra.paintRects[VERTICAL].height;

            // if benefit is comparable with bounding box

            if (MAX_BENEFIT_RATIO * benefit < square) {

                ra.paintRects[HORIZONTAL] = paintRect;

                ra.paintRects[VERTICAL] = null;

            }

        }

        for (int i = 0; i < paintRects.length; i++) {

            if (ra.paintRects[i] != null

                && !ra.paintRects[i].isEmpty())

            {

                // Should use separate Graphics for each paint() call,

                // since paint() can change Graphics state for next call.

                Graphics g = comp.getGraphics();

                if (g != null) {

                    try {

                        g.setClip(ra.paintRects[i]);

                        if (i == UPDATE) {

                            updateComponent(comp, g);

                        } else {

                            if (shouldClearRectBeforePaint) {

                                g.clearRect( ra.paintRects[i].x,

                                             ra.paintRects[i].y,

                                             ra.paintRects[i].width,

                                             ra.paintRects[i].height);

                            }

                            paintComponent(comp, g);

                        }

                    } finally {

                        g.dispose();

                    }

                }

            }

        }

    }

    /**

     * Calls <code>Component.update(Graphics)</code> with given Graphics.

     */

    protected void updateComponent(Component comp, Graphics g) {

        if (comp != null) {

            comp.update(g);

        }

    }

    /**

     * Calls <code>Component.paint(Graphics)</code> with given Graphics.

     */

    protected void paintComponent(Component comp, Graphics g) {

        if (comp != null) {

            comp.paint(g);

        }

    }

    /**

     * Subtracts subtr from rect. If the result is rectangle

     * changes rect and returns true. Otherwise false.

     */

    static boolean subtract(Rectangle rect, Rectangle subtr) {

        if (rect == null || subtr == null) {

            return true;

        }

        Rectangle common = rect.intersection(subtr);

        if (common.isEmpty()) {

            return true;

        }

        if (rect.x == common.x && rect.y == common.y) {

            if (rect.width == common.width) {

                rect.y += common.height;

                rect.height -= common.height;

                return true;

            } else

            if (rect.height == common.height) {

                rect.x += common.width;

                rect.width -= common.width;

                return true;

            }

        } else

        if (rect.x + rect.width == common.x + common.width

            && rect.y + rect.height == common.y + common.height)

        {

            if (rect.width == common.width) {

                rect.height -= common.height;

                return true;

            } else

            if (rect.height == common.height) {

                rect.width -= common.width;

                return true;

            }

        }

        return false;

    }

    public String toString() {

        return super.toString() + "[ horizontal=" + paintRects[0] +

            " vertical=" + paintRects[1] +

            " update=" + paintRects[2] + "]";

    }

}