/* ========================================================================
 * JCommon : a free general purpose class library for the Java(tm) platform
 * ========================================================================
 *
 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
 * 
 * Project Info:  http://www.jfree.org/jcommon/index.html
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
 * USA.  
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
 * in the United States and other countries.]
 *
 * -------------------
 * VerticalLayout.java
 * -------------------
 * (C)opyright 2003, by Thomas Morgner and Contributors.
 *
 * Original Author:  Thomas Morgner;
 * Contributor(s):   David Gilbert (for Simba Management Limited);
 *
 * $Id: VerticalLayout.java,v 1.2 2005/10/18 13:23:37 mungady Exp $
 *
 * Changes 
 * -------------------------
 * 31.08.2003 : Initial version
 *  
 */

package org.jfree.ui.tabbedui;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Insets;
import java.awt.LayoutManager;
import java.awt.Rectangle;

/**
 * A simple layout manager, which aligns all components in a vertical
 * flow layout.
 * 
 * @author Thomas Morgner
 */
public class VerticalLayout implements LayoutManager {
    
    /**
     * Defines, whether to use the parents size or whether to compute
     * the size from the parent's childs during the layouting.
     */
    private final boolean useSizeFromParent;

    /**
     * DefaultConstructor.
     */
    public VerticalLayout() {
        this(true);
    }

    /**
     * Creates a new vertical layout. If useParent is set to true,
     * the parents size will be used when performing the layouting,
     * else only the parents childs are used to compute the layout.
     *
     * @param useParent defines, whether the parent's size is used.
     */
    public VerticalLayout(final boolean useParent) {
        this.useSizeFromParent = useParent;
    }

    /**
     * Adds the specified component with the specified name to
     * the layout.
     *
     * @param name the component name
     * @param comp the component to be added
     */
    public void addLayoutComponent(final String name, final Component comp) {
        // ignored
    }

    /**
     * Removes the specified component from the layout.
     *
     * @param comp the component to be removed
     */
    public void removeLayoutComponent(final Component comp) {
        // ignored
    }

    /**
     * Calculates the preferred size dimensions for the specified
     * panel given the components in the specified parent container.
     *
     * @param parent the component to be laid out
     * @return the preferred layout size
     * @see #minimumLayoutSize
     */
    public Dimension preferredLayoutSize(final Container parent) {
        synchronized (parent.getTreeLock()) {
            final Insets ins = parent.getInsets();
            final Component[] comps = parent.getComponents();
            int height = ins.top + ins.bottom;
            int width = ins.left + ins.right;
            for (int i = 0; i < comps.length; i++) {
                if (comps[i].isVisible() == false) {
                    continue;
                }
                final Dimension pref = comps[i].getPreferredSize();
                height += pref.height;
                if (pref.width > width) {
                    width = pref.width;
                }
            }

            return new Dimension(width + ins.left + ins.right,
                height + ins.top + ins.bottom);
        }
    }

    /**
     * Calculates the minimum size dimensions for the specified
     * panel given the components in the specified parent container.
     *
     * @param parent the component to be laid out
     * @return the minimul layoutsize
     * @see #preferredLayoutSize
     */
    public Dimension minimumLayoutSize(final Container parent) {
        synchronized (parent.getTreeLock()) {
            final Insets ins = parent.getInsets();
            final Component[] comps = parent.getComponents();
            int height = ins.top + ins.bottom;
            int width = ins.left + ins.right;
            for (int i = 0; i < comps.length; i++) {
                if (comps[i].isVisible() == false) {
                    continue;
                }
                final Dimension min = comps[i].getMinimumSize();
                height += min.height;
                if (min.width > width) {
                    width = min.width;
                }
            }
            return new Dimension(width + ins.left + ins.right,
                height + ins.top + ins.bottom);
        }
    }

    /**
     * Returns, whether the parent's defined size is used during the layouting,
     * or whether the childs are used to compute the size.
     *
     * @return true, if the parent's size is used, false otherwise.
     */
    public boolean isUseSizeFromParent() {
        return this.useSizeFromParent;
    }

    /**
     * Lays out the container in the specified panel.
     *
     * @param parent the component which needs to be laid out
     */
    public void layoutContainer(final Container parent) {
        synchronized (parent.getTreeLock()) {
            final Insets ins = parent.getInsets();
            final int insHorizontal = ins.left + ins.right;

            final int width;
            if (isUseSizeFromParent()) {
                final Rectangle bounds = parent.getBounds();
                width = bounds.width - insHorizontal;
            }
            else {
                width = preferredLayoutSize(parent).width - insHorizontal;
            }
            final Component[] comps = parent.getComponents();

            int y = ins.top;
            for (int i = 0; i < comps.length; i++) {
                final Component c = comps[i];
                if (c.isVisible() == false) {
                    continue;
                }
                final Dimension dim = c.getPreferredSize();
                c.setBounds(ins.left, y, width, dim.height);
                y += dim.height;
            }
        }
    }
}