/* class BoxLayout
 *
 * Copyright (C) 2001  R M Pitman
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package charvax.swing;

import charva.awt.Component;
import charva.awt.Container;
import charva.awt.Dimension;
import charva.awt.Insets;
import charva.awt.LayoutManager;

/**
 * A concrete implementation of LayoutManager that lays out its components
 * horizontally or vertically.
 */
public class BoxLayout implements LayoutManager {

    /**
     * Creates a layout manager that will lay out its components either
     * left-to-right or top-to-bottom, as specified by the axis_ parameter.
     * 
     * @param target_
     *            The container to be laid out. This parameter is not used, but
     *            is present for compatibility with the javax.swing.BoxLayout
     *            constructor).
     * @param axis_
     *            The axis in which components wil be laid out. Must be X_AXIS
     *            or Y_AXIS.
     */
    public BoxLayout(Container target_, int axis_) {
        //_target = target_;
        if (axis_ != X_AXIS && axis_ != Y_AXIS)
                throw new IllegalArgumentException("illegal axis");

        _axis = axis_;
    }

    /**
     * Calculate the minimum-size rectangle that can enclose all the components
     * in the given container.
     */
    public Dimension minimumSize(Container container_) {

        Dimension size = new Dimension(0, 0);

        Component[] components = container_.getComponents();
        for (int i = 0; i < components.length; i++) {
            Component c = components[ i];
            Dimension d = c.minimumSize();
            if (_axis == X_AXIS) {
                size.width += d.width;
                if (d.height > size.height) size.height = d.height;
            } else {
                size.height += d.height;
                if (d.width > size.width) size.width = d.width;
            }
        }

        /*
         * Take into account the border frame (if any).
         */
        Insets insets = container_.getInsets();
        size.width += insets.left + insets.right;
        size.height += insets.top + insets.bottom;

        return size;
    }

    /**
     * This is called when the size of the container has already been
     * calculated. It just lays out the components according to the specified
     * alignment.
     */
    public void doLayout(Container container_) {

        Dimension containersize = container_.getSize();
        Dimension minsize = minimumSize(container_);

        /*
         * Ensure that the container is at least as large as the minimum size.
         */
        if (containersize.width < minsize.width)
                containersize.width = minsize.width;
        if (containersize.height < minsize.height)
                containersize.height = minsize.height;
        container_.setSize(containersize);

        Component[] components = container_.getComponents();
        int hoffset = container_.getInsets().left;
        int voffset = container_.getInsets().top;
        for (int i = 0; i < components.length; i++) {

            Component c = components[ i];

            /*
             * Get the contained container to lay itself out at its preferred
             * size.
             */
            if (c instanceof Container) {
                Container cont = (Container) c;
                cont.setSize(cont.minimumSize());
                cont.doLayout();
            }

            Dimension componentsize = c.getSize();
            if (_axis == X_AXIS) {
                float alignment = c.getAlignmentY();
                if (alignment == Component.TOP_ALIGNMENT)
                    voffset = container_.getInsets().top;
                else if (alignment == Component.CENTER_ALIGNMENT) {
                    voffset = (containersize.height - componentsize.height) / 2;
                } else if (alignment == Component.BOTTOM_ALIGNMENT) {
                    voffset = containersize.height
                            - container_.getInsets().bottom
                            - componentsize.height;
                }
                c.setLocation(hoffset, voffset);
                hoffset += componentsize.width;
            } else {
                float alignment = c.getAlignmentX();
                if (alignment == Component.LEFT_ALIGNMENT)
                    hoffset = container_.getInsets().left;
                else if (alignment == Component.CENTER_ALIGNMENT) {
                    hoffset = (containersize.width - componentsize.width) / 2;
                } else if (alignment == Component.RIGHT_ALIGNMENT) {
                    hoffset = containersize.width
                            - container_.getInsets().right
                            - componentsize.width;
                }
                c.setLocation(hoffset, voffset);
                voffset += componentsize.height;
            }
        }
    }

    //====================================================================
    // INSTANCE VARIABLES

    //private final Container _target;

    private int _axis;

    public static final int X_AXIS = 100;

    public static final int Y_AXIS = 101;
}