    001    /* ========================================================================
    002     * JCommon : a free general purpose class library for the Java(tm) platform
    003     * ========================================================================
    004     *
    005     * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
    006     *
    007     * Project Info:  http://www.jfree.org/jcommon/index.html
    008     *
    009     * This library is free software; you can redistribute it and/or modify it
    010     * under the terms of the GNU Lesser General Public License as published by
    011     * the Free Software Foundation; either version 2.1 of the License, or
    012     * (at your option) any later version.
    013     *
    014     * This library is distributed in the hope that it will be useful, but
    015     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    016     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
    017     * License for more details.
    018     *
    019     * You should have received a copy of the GNU Lesser General Public
    020     * License along with this library; if not, write to the Free Software
    021     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
    022     * USA.
    023     *
    024     * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
    025     * in the United States and other countries.]
    026     *
    027     * ------------------------------
    028     * OverlayLayout.java
    029     * ------------------------------
    030     * (C)opyright 2003, by Thomas Morgner and Contributors.
    031     *
    032     * Original Author:  Thomas Morgner;
    033     * Contributor(s):   -;
    034     *
    035     * $Id: OverlayLayout.java,v 1.5 2005/10/18 13:18:34 mungady Exp $
    036     *
    037     * Changes
    038     * -------------------------
    039     * 09-12-2003 : Initial version
    040     *
    041     */
    042    package org.jfree.ui;
    043
    044    import java.awt.Component;
    045    import java.awt.Container;
    046    import java.awt.Dimension;
    047    import java.awt.Insets;
    048    import java.awt.LayoutManager;
    049    import java.awt.Rectangle;
    050
    051    /**
    052     * A simple layoutmanager to overlay all components of a parent.
    053     * <p/>
    054     * This layout manager acts similiar to the card layout, but all
    055     * childs of the parent band have the same size and all childs can
    056     * be visible at the same time.
    057     *
    058     * @author Thomas Morgner
    059     */
    060    public final class OverlayLayout implements LayoutManager {
    061
    062        /**
    063         * A flag that defines, whether invisible components should be ignored when
    064         * computing the layout.
    065         */
    066        private boolean ignoreInvisible;
    067
    068        /**
    069         * Creates a new instance.
    070         *
    071         * @param ignoreInvisible  whether to ignore invisible components when computing the layout.
    072         */
    073        public OverlayLayout(final boolean ignoreInvisible) {
    074            this.ignoreInvisible = ignoreInvisible;
    075        }
    076
    077        /**
    078         * DefaultConstructor.
    079         */
    080        public OverlayLayout() {
    081
    082        }
    083
    084        /**
    085         * If the layout manager uses a per-component string,
    086         * adds the component <code>comp</code> to the layout,
    087         * associating it
    088         * with the string specified by <code>name</code>.
    089         *
    090         * @param name the string to be associated with the component
    091         * @param comp the component to be added
    092         */
    093        public void addLayoutComponent(final String name, final Component comp) {
    094        }
    095
    096        /**
    097         * Removes the specified component from the layout.
    098         *
    099         * @param comp the component to be removed
    100         */
    101        public void removeLayoutComponent(final Component comp) {
    102        }
    103
    104        /**
    105         * Lays out the specified container.
    106         *
    107         * @param parent the container to be laid out
    108         */
    109        public void layoutContainer(final Container parent) {
    110            synchronized (parent.getTreeLock()) {
    111                final Insets ins = parent.getInsets();
    112
    113                final Rectangle bounds = parent.getBounds();
    114                final int width = bounds.width - ins.left - ins.right;
    115                final int height = bounds.height - ins.top - ins.bottom;
    116
    117                final Component[] comps = parent.getComponents();
    118
    119                for (int i = 0; i < comps.length; i++) {
    120                    final Component c = comps[i];
    121                    if ((comps[i].isVisible() == false) && this.ignoreInvisible) {
    122                        continue;
    123                    }
    124                    c.setBounds(ins.left, ins.top, width, height);
    125                }
    126            }
    127        }
    128
    129        /**
    130         * Calculates the minimum size dimensions for the specified
    131         * container, given the components it contains.
    132         *
    133         * @param parent the component to be laid out
    134         * @return the minimum size computed for the parent.
    135         * @see #preferredLayoutSize
    136         */
    137        public Dimension minimumLayoutSize(final Container parent) {
    138            synchronized (parent.getTreeLock()) {
    139                final Insets ins = parent.getInsets();
    140                final Component[] comps = parent.getComponents();
    141                int height = 0;
    142                int width = 0;
    143                for (int i = 0; i < comps.length; i++) {
    144                    if ((comps[i].isVisible() == false) && this.ignoreInvisible) {
    145                        continue;
    146                    }
    147
    148                    final Dimension pref = comps[i].getMinimumSize();
    149                    if (pref.height > height) {
    150                        height = pref.height;
    151                    }
    152                    if (pref.width > width) {
    153                        width = pref.width;
    154                    }
    155                }
    156                return new Dimension(width + ins.left + ins.right,
    157                    height + ins.top + ins.bottom);
    158            }
    159        }
    160
    161        /**
    162         * Calculates the preferred size dimensions for the specified
    163         * container, given the components it contains.
    164         *
    165         * @param parent the container to be laid out
    166         * @return the preferred size computed for the parent.
    167         * @see #minimumLayoutSize
    168         */
    169        public Dimension preferredLayoutSize(final Container parent) {
    170            synchronized (parent.getTreeLock()) {
    171                final Insets ins = parent.getInsets();
    172                final Component[] comps = parent.getComponents();
    173                int height = 0;
    174                int width = 0;
    175                for (int i = 0; i < comps.length; i++) {
    176                    if ((comps[i].isVisible() == false) && this.ignoreInvisible) {
    177                        continue;
    178                    }
    179
    180                    final Dimension pref = comps[i].getPreferredSize();
    181                    if (pref.height > height) {
    182                        height = pref.height;
    183                    }
    184                    if (pref.width > width) {
    185                        width = pref.width;
    186                    }
    187                }
    188                return new Dimension(width + ins.left + ins.right,
    189                    height + ins.top + ins.bottom);
    190            }
    191        }
    192
    193    }