KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jfree > ui > OverlayLayout


1 /* ========================================================================
2  * JCommon : a free general purpose class library for the Java(tm) platform
3  * ========================================================================
4  *
5  * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
6  *
7  * Project Info: http://www.jfree.org/jcommon/index.html
8  *
9  * This library is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
17  * License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
22  * USA.
23  *
24  * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
25  * in the United States and other countries.]
26  *
27  * ------------------------------
28  * OverlayLayout.java
29  * ------------------------------
30  * (C)opyright 2003, by Thomas Morgner and Contributors.
31  *
32  * Original Author: Thomas Morgner;
33  * Contributor(s): -;
34  *
35  * $Id: OverlayLayout.java,v 1.5 2005/10/18 13:18:34 mungady Exp $
36  *
37  * Changes
38  * -------------------------
39  * 09-12-2003 : Initial version
40  *
41  */
42 package org.jfree.ui;
43
44 import java.awt.Component JavaDoc;
45 import java.awt.Container JavaDoc;
46 import java.awt.Dimension JavaDoc;
47 import java.awt.Insets JavaDoc;
48 import java.awt.LayoutManager JavaDoc;
49 import java.awt.Rectangle JavaDoc;
50
51 /**
52  * A simple layoutmanager to overlay all components of a parent.
53  * <p/>
54  * This layout manager acts similiar to the card layout, but all
55  * childs of the parent band have the same size and all childs can
56  * be visible at the same time.
57  *
58  * @author Thomas Morgner
59  */
60 public final class OverlayLayout implements LayoutManager JavaDoc {
61
62     /**
63      * A flag that defines, whether invisible components should be ignored when
64      * computing the layout.
65      */
66     private boolean ignoreInvisible;
67
68     /**
69      * Creates a new instance.
70      *
71      * @param ignoreInvisible whether to ignore invisible components when computing the layout.
72      */
73     public OverlayLayout(final boolean ignoreInvisible) {
74         this.ignoreInvisible = ignoreInvisible;
75     }
76
77     /**
78      * DefaultConstructor.
79      */
80     public OverlayLayout() {
81
82     }
83
84     /**
85      * If the layout manager uses a per-component string,
86      * adds the component <code>comp</code> to the layout,
87      * associating it
88      * with the string specified by <code>name</code>.
89      *
90      * @param name the string to be associated with the component
91      * @param comp the component to be added
92      */
93     public void addLayoutComponent(final String JavaDoc name, final Component JavaDoc comp) {
94     }
95
96     /**
97      * Removes the specified component from the layout.
98      *
99      * @param comp the component to be removed
100      */
101     public void removeLayoutComponent(final Component JavaDoc 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 JavaDoc parent) {
110         synchronized (parent.getTreeLock()) {
111             final Insets JavaDoc ins = parent.getInsets();
112
113             final Rectangle JavaDoc 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 JavaDoc[] comps = parent.getComponents();
118
119             for (int i = 0; i < comps.length; i++) {
120                 final Component JavaDoc 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 JavaDoc minimumLayoutSize(final Container JavaDoc parent) {
138         synchronized (parent.getTreeLock()) {
139             final Insets JavaDoc ins = parent.getInsets();
140             final Component JavaDoc[] 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 JavaDoc 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 JavaDoc(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 JavaDoc preferredLayoutSize(final Container JavaDoc parent) {
170         synchronized (parent.getTreeLock()) {
171             final Insets JavaDoc ins = parent.getInsets();
172             final Component JavaDoc[] 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 JavaDoc 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 JavaDoc(width + ins.left + ins.right,
189                 height + ins.top + ins.bottom);
190         }
191     }
192
193 }
194
Popular Tags