/*

 * 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 java.awt;

import java.io.ObjectInputStream;

import java.io.IOException;

/**

 * A flow layout arranges components in a directional flow, much

 * like lines of text in a paragraph. The flow direction is

 * determined by the container's {@code componentOrientation}

 * property and may be one of two values:

 * <ul>

 * <li>{@code ComponentOrientation.LEFT_TO_RIGHT}

 * <li>{@code ComponentOrientation.RIGHT_TO_LEFT}

 * </ul>

 * Flow layouts are typically used

 * to arrange buttons in a panel. It arranges buttons

 * horizontally until no more buttons fit on the same line.

 * The line alignment is determined by the {@code align}

 * property. The possible values are:

 * <ul>

 * <li>{@link #LEFT LEFT}

 * <li>{@link #RIGHT RIGHT}

 * <li>{@link #CENTER CENTER}

 * <li>{@link #LEADING LEADING}

 * <li>{@link #TRAILING TRAILING}

 * </ul>

 * <p>

 * For example, the following picture shows an applet using the flow

 * layout manager (its default layout manager) to position three buttons:

 * <p>

 * <img src="doc-files/FlowLayout-1.gif"

 * ALT="Graphic of Layout for Three Buttons"

 * <p>

 * Here is the code for this applet:

 *

 * <hr><blockquote><pre>

 * import java.awt.*;

 * import java.applet.Applet;

 *

 * public class myButtons extends Applet {

 *     Button button1, button2, button3;

 *     public void init() {

 *         button1 = new Button("Ok");

 *         button2 = new Button("Open");

 *         button3 = new Button("Close");

 *         add(button1);

 *         add(button2);

 *         add(button3);

 *     }

 * }

 * </pre></blockquote><hr>

 * <p>

 * A flow layout lets each component assume its natural (preferred) size.

 *

 * @author      Arthur van Hoff

 * @author      Sami Shaio

 * @since       1.0

 * @see ComponentOrientation

 */

public class FlowLayout implements LayoutManager, java.io.Serializable {

    /**

     * This value indicates that each row of components

     * should be left-justified.

     */

    public static final int LEFT        = 0;

    /**

     * This value indicates that each row of components

     * should be centered.

     */

    public static final int CENTER      = 1;

    /**

     * This value indicates that each row of components

     * should be right-justified.

     */

    public static final int RIGHT       = 2;

    /**

     * This value indicates that each row of components

     * should be justified to the leading edge of the container's

     * orientation, for example, to the left in left-to-right orientations.

     *

     * @see     java.awt.Component#getComponentOrientation

     * @see     java.awt.ComponentOrientation

     * @since   1.2

     */

    public static final int LEADING     = 3;

    /**

     * This value indicates that each row of components

     * should be justified to the trailing edge of the container's

     * orientation, for example, to the right in left-to-right orientations.

     *

     * @see     java.awt.Component#getComponentOrientation

     * @see     java.awt.ComponentOrientation

     * @since   1.2

     */

    public static final int TRAILING = 4;

    /**

     * {@code align} is the property that determines

     * how each row distributes empty space.

     * It can be one of the following values:

     * <ul>

     * <li>{@code LEFT}

     * <li>{@code RIGHT}

     * <li>{@code CENTER}

     * </ul>

     *

     * @serial

     * @see #getAlignment

     * @see #setAlignment

     */

    int align;          // This is for 1.1 serialization compatibility

    /**

     * {@code newAlign} is the property that determines

     * how each row distributes empty space for the Java 2 platform,

     * v1.2 and greater.

     * It can be one of the following three values:

     * <ul>

     * <li>{@code LEFT}

     * <li>{@code RIGHT}

     * <li>{@code CENTER}

     * <li>{@code LEADING}

     * <li>{@code TRAILING}

     * </ul>

     *

     * @serial

     * @since 1.2

     * @see #getAlignment

     * @see #setAlignment

     */

    int newAlign;       // This is the one we actually use

    /**

     * The flow layout manager allows a separation of

     * components with gaps.  The horizontal gap will

     * specify the space between components and between

     * the components and the borders of the

     * {@code Container}.

     *

     * @serial

     * @see #getHgap()

     * @see #setHgap(int)

     */

    int hgap;

    /**

     * The flow layout manager allows a separation of

     * components with gaps.  The vertical gap will

     * specify the space between rows and between the

     * the rows and the borders of the {@code Container}.

     *

     * @serial

     * @see #getHgap()

     * @see #setHgap(int)

     */

    int vgap;

    /**

     * If true, components will be aligned on their baseline.

     */

    private boolean alignOnBaseline;

    /*

     * JDK 1.1 serialVersionUID

     */

     private static final long serialVersionUID = -7262534875583282631L;

    /**

     * Constructs a new {@code FlowLayout} with a centered alignment and a

     * default 5-unit horizontal and vertical gap.

     */

    public FlowLayout() {

        this(CENTER, 5, 5);

    }

    /**

     * Constructs a new {@code FlowLayout} with the specified

     * alignment and a default 5-unit horizontal and vertical gap.

     * The value of the alignment argument must be one of

     * {@code FlowLayout.LEFT}, {@code FlowLayout.RIGHT},

     * {@code FlowLayout.CENTER}, {@code FlowLayout.LEADING},

     * or {@code FlowLayout.TRAILING}.

     * @param align the alignment value

     */

    public FlowLayout(int align) {

        this(align, 5, 5);

    }

    /**

     * Creates a new flow layout manager with the indicated alignment

     * and the indicated horizontal and vertical gaps.

     * <p>

     * The value of the alignment argument must be one of

     * {@code FlowLayout.LEFT}, {@code FlowLayout.RIGHT},

     * {@code FlowLayout.CENTER}, {@code FlowLayout.LEADING},

     * or {@code FlowLayout.TRAILING}.

     * @param      align   the alignment value

     * @param      hgap    the horizontal gap between components

     *                     and between the components and the

     *                     borders of the {@code Container}

     * @param      vgap    the vertical gap between components

     *                     and between the components and the

     *                     borders of the {@code Container}

     */

    public FlowLayout(int align, int hgap, int vgap) {

        this.hgap = hgap;

        this.vgap = vgap;

        setAlignment(align);

    }

    /**

     * Gets the alignment for this layout.

     * Possible values are {@code FlowLayout.LEFT},

     * {@code FlowLayout.RIGHT}, {@code FlowLayout.CENTER},

     * {@code FlowLayout.LEADING},

     * or {@code FlowLayout.TRAILING}.

     * @return     the alignment value for this layout

     * @see        java.awt.FlowLayout#setAlignment

     * @since      1.1

     */

    public int getAlignment() {

        return newAlign;

    }

    /**

     * Sets the alignment for this layout.

     * Possible values are

     * <ul>

     * <li>{@code FlowLayout.LEFT}

     * <li>{@code FlowLayout.RIGHT}

     * <li>{@code FlowLayout.CENTER}

     * <li>{@code FlowLayout.LEADING}

     * <li>{@code FlowLayout.TRAILING}

     * </ul>

     * @param      align one of the alignment values shown above

     * @see        #getAlignment()

     * @since      1.1

     */

    public void setAlignment(int align) {

        this.newAlign = align;

        // this.align is used only for serialization compatibility,

        // so set it to a value compatible with the 1.1 version

        // of the class

        switch (align) {

        case LEADING:

            this.align = LEFT;

            break;

        case TRAILING:

            this.align = RIGHT;

            break;

        default:

            this.align = align;

            break;

        }

    }

    /**

     * Gets the horizontal gap between components

     * and between the components and the borders

     * of the {@code Container}

     *

     * @return     the horizontal gap between components

     *             and between the components and the borders

     *             of the {@code Container}

     * @see        java.awt.FlowLayout#setHgap

     * @since      1.1

     */

    public int getHgap() {

        return hgap;

    }

    /**

     * Sets the horizontal gap between components and

     * between the components and the borders of the

     * {@code Container}.

     *

     * @param hgap the horizontal gap between components

     *             and between the components and the borders

     *             of the {@code Container}

     * @see        java.awt.FlowLayout#getHgap

     * @since      1.1

     */

    public void setHgap(int hgap) {

        this.hgap = hgap;

    }

    /**

     * Gets the vertical gap between components and

     * between the components and the borders of the

     * {@code Container}.

     *

     * @return     the vertical gap between components

     *             and between the components and the borders

     *             of the {@code Container}

     * @see        java.awt.FlowLayout#setVgap

     * @since      1.1

     */

    public int getVgap() {

        return vgap;

    }

    /**

     * Sets the vertical gap between components and between

     * the components and the borders of the {@code Container}.

     *

     * @param vgap the vertical gap between components

     *             and between the components and the borders

     *             of the {@code Container}

     * @see        java.awt.FlowLayout#getVgap

     * @since      1.1

     */

    public void setVgap(int vgap) {

        this.vgap = vgap;

    }

    /**

     * Sets whether or not components should be vertically aligned along their

     * baseline.  Components that do not have a baseline will be centered.

     * The default is false.

     *

     * @param alignOnBaseline whether or not components should be

     *                        vertically aligned on their baseline

     * @since 1.6

     */

    public void setAlignOnBaseline(boolean alignOnBaseline) {

        this.alignOnBaseline = alignOnBaseline;

    }

    /**

     * Returns true if components are to be vertically aligned along

     * their baseline.  The default is false.

     *

     * @return true if components are to be vertically aligned along

     *              their baseline

     * @since 1.6

     */

    public boolean getAlignOnBaseline() {

        return alignOnBaseline;

    }

    /**

     * Adds the specified component to the layout.

     * Not used by this class.

     * @param name the name of the component

     * @param comp the component to be added

     */

    public void addLayoutComponent(String name, Component comp) {

    }

    /**

     * Removes the specified component from the layout.

     * Not used by this class.

     * @param comp the component to remove

     * @see       java.awt.Container#removeAll

     */

    public void removeLayoutComponent(Component comp) {

    }

    /**

     * Returns the preferred dimensions for this layout given the

     * <i>visible</i> components in the specified target container.

     *

     * @param target the container that needs to be laid out

     * @return    the preferred dimensions to lay out the

     *            subcomponents of the specified container

     * @see Container

     * @see #minimumLayoutSize

     * @see       java.awt.Container#getPreferredSize

     */

    public Dimension preferredLayoutSize(Container target) {

      synchronized (target.getTreeLock()) {

        Dimension dim = new Dimension(0, 0);

        int nmembers = target.getComponentCount();

        boolean firstVisibleComponent = true;

        boolean useBaseline = getAlignOnBaseline();

        int maxAscent = 0;

        int maxDescent = 0;

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

            Component m = target.getComponent(i);

            if (m.isVisible()) {

                Dimension d = m.getPreferredSize();

                dim.height = Math.max(dim.height, d.height);

                if (firstVisibleComponent) {

                    firstVisibleComponent = false;

                } else {

                    dim.width += hgap;

                }

                dim.width += d.width;

                if (useBaseline) {

                    int baseline = m.getBaseline(d.width, d.height);

                    if (baseline >= 0) {

                        maxAscent = Math.max(maxAscent, baseline);

                        maxDescent = Math.max(maxDescent, d.height - baseline);

                    }

                }

            }

        }

        if (useBaseline) {

            dim.height = Math.max(maxAscent + maxDescent, dim.height);

        }

        Insets insets = target.getInsets();

        dim.width += insets.left + insets.right + hgap*2;

        dim.height += insets.top + insets.bottom + vgap*2;

        return dim;

      }

    }

    /**

     * Returns the minimum dimensions needed to layout the <i>visible</i>

     * components contained in the specified target container.

     * @param target the container that needs to be laid out

     * @return    the minimum dimensions to lay out the

     *            subcomponents of the specified container

     * @see #preferredLayoutSize

     * @see       java.awt.Container

     * @see       java.awt.Container#doLayout

     */

    public Dimension minimumLayoutSize(Container target) {

      synchronized (target.getTreeLock()) {

        boolean useBaseline = getAlignOnBaseline();

        Dimension dim = new Dimension(0, 0);

        int nmembers = target.getComponentCount();

        int maxAscent = 0;

        int maxDescent = 0;

        boolean firstVisibleComponent = true;

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

            Component m = target.getComponent(i);

            if (m.visible) {

                Dimension d = m.getMinimumSize();

                dim.height = Math.max(dim.height, d.height);

                if (firstVisibleComponent) {

                    firstVisibleComponent = false;

                } else {

                    dim.width += hgap;

                }

                dim.width += d.width;

                if (useBaseline) {

                    int baseline = m.getBaseline(d.width, d.height);

                    if (baseline >= 0) {

                        maxAscent = Math.max(maxAscent, baseline);

                        maxDescent = Math.max(maxDescent,

                                              dim.height - baseline);

                    }

                }

}

}

        if (useBaseline) {

            dim.height = Math.max(maxAscent + maxDescent, dim.height);

        }

        Insets insets = target.getInsets();

        dim.width += insets.left + insets.right + hgap*2;

        dim.height += insets.top + insets.bottom + vgap*2;

        return dim;

      }

    }

    /**

     * Centers the elements in the specified row, if there is any slack.

     * @param target the component which needs to be moved

     * @param x the x coordinate

     * @param y the y coordinate

     * @param width the width dimensions

     * @param height the height dimensions

     * @param rowStart the beginning of the row

     * @param rowEnd the ending of the row

     * @param useBaseline Whether or not to align on baseline.

     * @param ascent Ascent for the components. This is only valid if

     *               useBaseline is true.

     * @param descent Ascent for the components. This is only valid if

     *               useBaseline is true.

     * @return actual row height

     */

    private int moveComponents(Container target, int x, int y, int width, int height,

                                int rowStart, int rowEnd, boolean ltr,

                                boolean useBaseline, int[] ascent,

                                int[] descent) {

        switch (newAlign) {

        case LEFT: