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: * VerticalLayout.java
029: * -------------------
030: * (C)opyright 2003, by Thomas Morgner and Contributors.
031: *
032: * Original Author: Thomas Morgner;
033: * Contributor(s): David Gilbert (for Simba Management Limited);
034: *
035: * $Id: VerticalLayout.java,v 1.2 2005/10/18 13:23:37 mungady Exp $
036: *
037: * Changes
038: * -------------------------
039: * 31.08.2003 : Initial version
040: *
041: */
042:
043: package org.jfree.ui.tabbedui;
044:
045: import java.awt.Component;
046: import java.awt.Container;
047: import java.awt.Dimension;
048: import java.awt.Insets;
049: import java.awt.LayoutManager;
050: import java.awt.Rectangle;
051:
052: /**
053: * A simple layout manager, which aligns all components in a vertical
054: * flow layout.
055: *
056: * @author Thomas Morgner
057: */
058: public class VerticalLayout implements LayoutManager {
059:
060: /**
061: * Defines, whether to use the parents size or whether to compute
062: * the size from the parent's childs during the layouting.
063: */
064: private final boolean useSizeFromParent;
065:
066: /**
067: * DefaultConstructor.
068: */
069: public VerticalLayout() {
070: this (true);
071: }
072:
073: /**
074: * Creates a new vertical layout. If useParent is set to true,
075: * the parents size will be used when performing the layouting,
076: * else only the parents childs are used to compute the layout.
077: *
078: * @param useParent defines, whether the parent's size is used.
079: */
080: public VerticalLayout(final boolean useParent) {
081: this .useSizeFromParent = useParent;
082: }
083:
084: /**
085: * Adds the specified component with the specified name to
086: * the layout.
087: *
088: * @param name the component name
089: * @param comp the component to be added
090: */
091: public void addLayoutComponent(final String name,
092: final Component comp) {
093: // ignored
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: // ignored
103: }
104:
105: /**
106: * Calculates the preferred size dimensions for the specified
107: * panel given the components in the specified parent container.
108: *
109: * @param parent the component to be laid out
110: * @return the preferred layout size
111: * @see #minimumLayoutSize
112: */
113: public Dimension preferredLayoutSize(final Container parent) {
114: synchronized (parent.getTreeLock()) {
115: final Insets ins = parent.getInsets();
116: final Component[] comps = parent.getComponents();
117: int height = ins.top + ins.bottom;
118: int width = ins.left + ins.right;
119: for (int i = 0; i < comps.length; i++) {
120: if (comps[i].isVisible() == false) {
121: continue;
122: }
123: final Dimension pref = comps[i].getPreferredSize();
124: height += pref.height;
125: if (pref.width > width) {
126: width = pref.width;
127: }
128: }
129:
130: return new Dimension(width + ins.left + ins.right, height
131: + ins.top + ins.bottom);
132: }
133: }
134:
135: /**
136: * Calculates the minimum size dimensions for the specified
137: * panel given the components in the specified parent container.
138: *
139: * @param parent the component to be laid out
140: * @return the minimul layoutsize
141: * @see #preferredLayoutSize
142: */
143: public Dimension minimumLayoutSize(final Container parent) {
144: synchronized (parent.getTreeLock()) {
145: final Insets ins = parent.getInsets();
146: final Component[] comps = parent.getComponents();
147: int height = ins.top + ins.bottom;
148: int width = ins.left + ins.right;
149: for (int i = 0; i < comps.length; i++) {
150: if (comps[i].isVisible() == false) {
151: continue;
152: }
153: final Dimension min = comps[i].getMinimumSize();
154: height += min.height;
155: if (min.width > width) {
156: width = min.width;
157: }
158: }
159: return new Dimension(width + ins.left + ins.right, height
160: + ins.top + ins.bottom);
161: }
162: }
163:
164: /**
165: * Returns, whether the parent's defined size is used during the layouting,
166: * or whether the childs are used to compute the size.
167: *
168: * @return true, if the parent's size is used, false otherwise.
169: */
170: public boolean isUseSizeFromParent() {
171: return this .useSizeFromParent;
172: }
173:
174: /**
175: * Lays out the container in the specified panel.
176: *
177: * @param parent the component which needs to be laid out
178: */
179: public void layoutContainer(final Container parent) {
180: synchronized (parent.getTreeLock()) {
181: final Insets ins = parent.getInsets();
182: final int insHorizontal = ins.left + ins.right;
183:
184: final int width;
185: if (isUseSizeFromParent()) {
186: final Rectangle bounds = parent.getBounds();
187: width = bounds.width - insHorizontal;
188: } else {
189: width = preferredLayoutSize(parent).width
190: - insHorizontal;
191: }
192: final Component[] comps = parent.getComponents();
193:
194: int y = ins.top;
195: for (int i = 0; i < comps.length; i++) {
196: final Component c = comps[i];
197: if (c.isVisible() == false) {
198: continue;
199: }
200: final Dimension dim = c.getPreferredSize();
201: c.setBounds(ins.left, y, width, dim.height);
202: y += dim.height;
203: }
204: }
205: }
206: }
|