1 /*
2 * Copyright (c) 1996, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package sun.awt;
26
27 import java.awt.*;
28
29 /**
30 * Extends the FlowLayout class to support both vertical and horizontal
31 * layout of components. Orientation can be changed dynamically after
32 * creation by calling either of the methods @method orientHorizontally or
33 * @method orientVertically. Separate values for alignment, vertical gap,
34 * and horizontal gap can be specified for horizontal and vertical
35 * orientation.
36 *
37 * @author Terry Cline
38 */
39 public class OrientableFlowLayout extends FlowLayout {
40 /**
41 * The horizontal orientation constant.
42 */
43 public static final int HORIZONTAL = 0;
44
45 /**
46 * The vertical orientation constant.
47 */
48 public static final int VERTICAL = 1;
49
50 /**
51 * The top vertical alignment constant.
52 */
53 public static final int TOP = 0;
54
55 /**
56 * The bottom vertical alignment constant.
57 */
58 public static final int BOTTOM = 2; // CENTER == 1
59
60 int orientation;
61 int vAlign;
62 int vHGap;
63 int vVGap;
64
65 /**
66 * Constructs a new flow layout with a horizontal orientation and
67 * centered alignment.
68 */
69 public OrientableFlowLayout() {
70 this(HORIZONTAL, CENTER, CENTER, 5, 5, 5, 5);
71 }
72
73 /**
74 * Constructs a new flow layout with the specified orientation and
75 * a centered alignment.
76 *
77 * @param orientation the orientation, one of HORIZONTAL or VERTICAL.
78 */
79 public OrientableFlowLayout(int orientation) {
80 this(orientation, CENTER, CENTER, 5, 5, 5, 5);
81 }
82
83 /**
84 * Constructs a new flow layout with the specified orientation and
85 * alignment.
86 *
87 * @param orientation the orientation, one of HORIZONTAL or VERTICAL.
88 * @param hAlign the horizontal alignment, one of LEFT, CENTER, or RIGHT.
89 * @param vAlign the vertical alignment, one of TOP, CENTER, or BOTTOM.
90 */
91 public OrientableFlowLayout(int orientation, int hAlign, int vAlign) {
92 this(orientation, hAlign, vAlign, 5, 5, 5, 5);
93 }
94
95 /**
96 * Constructs a new flow layout with the specified orientation,
97 * alignment, and gap values.
98 *
99 * @param orientation the orientation, one of HORIZONTAL or VERTICAL.
100 * @param hAlign the horizontal alignment, one of LEFT, CENTER, or RIGHT.
101 * @param vAlign the vertical alignment, one of TOP, CENTER, or BOTTOM.
102 * @param hHGap the horizontal gap between components in HORIZONTAL.
103 * @param hVGap the vertical gap between components in HORIZONTAL.
104 * @param vHGap the horizontal gap between components in VERTICAL.
105 * @param vVGap the vertical gap between components in VERTICAL.
106 */
107 public OrientableFlowLayout(int orientation, int hAlign, int vAlign, int hHGap, int hVGap, int vHGap, int vVGap) {
108 super(hAlign, hHGap, hVGap);
109 this.orientation = orientation;
110 this.vAlign = vAlign;
111 this.vHGap = vHGap;
112 this.vVGap = vVGap;
113 }
114
115 /**
116 * Set the layout's current orientation to horizontal.
117 */
118 public synchronized void orientHorizontally() {
119 orientation = HORIZONTAL;
120 }
121
122 /**
123 * Set the layout's current orientation to vertical.
124 */
125 public synchronized void orientVertically() {
126 orientation = VERTICAL;
127 }
128
129 /**
130 * Returns the preferred dimensions for this layout given the
131 * components in the specified target container.
132 *
133 * @param target the component which needs to be laid out.
134 * @see Container
135 * @see FlowLayout
136 * @see #minimumLayoutSize
137 */
138 public Dimension preferredLayoutSize(Container target) {
139 if (orientation == HORIZONTAL) {
140 return super.preferredLayoutSize(target);
141 }
142 else {
143 Dimension dim = new Dimension(0, 0);
144
145 int n = target.countComponents();
146 for (int i = 0; i < n; i++) {
147 Component c = target.getComponent(i);
148 if (c.isVisible()) {
149 Dimension cDim = c.preferredSize();
150 dim.width = Math.max(dim.width, cDim.width);
151 if (i > 0) {
152 dim.height += vVGap;
153 }
154 dim.height += cDim.height;
155 }
156 }
157
158 Insets insets = target.insets();;
159 dim.width += insets.left + insets.right + vHGap*2;
160 dim.height += insets.top + insets.bottom + vVGap*2;
161
162 return dim;
163 }
164 }
165
166 /**
167 * Returns the minimum dimensions needed to layout the components
168 * contained in the specified target container.
169 *
170 * @param target the component which needs to be laid out.
171 * @see #preferredLayoutSize.
172 */
173 public Dimension minimumLayoutSize(Container target) {
174 if (orientation == HORIZONTAL) {
175 return super.minimumLayoutSize(target);
176 }
177 else {
178 Dimension dim = new Dimension(0, 0);
179
180 int n = target.countComponents();
181 for (int i = 0; i < n; i++) {
182 Component c = target.getComponent(i);
183 if (c.isVisible()) {
184 Dimension cDim = c.minimumSize();
185 dim.width = Math.max(dim.width, cDim.width);
186 if (i > 0) {
187 dim.height += vVGap;
188 }
189 dim.height += cDim.height;
190 }
191 }
192
193 Insets insets = target.insets();
194 dim.width += insets.left + insets.right + vHGap*2;
195 dim.height += insets.top + insets.bottom + vVGap*2;
196
197 return dim;
198 }
199 }
200
201 /**
202 * Lays out the container. This method will reshape the
203 * components in the target to satisfy the constraints of the
204 * layout.
205 *
206 * @param target the specified component being laid out.
207 * @see Container.
208 */
209 public void layoutContainer(Container target) {
210 if (orientation == HORIZONTAL) {
211 super.layoutContainer(target);
212 }
213 else {
214 Insets insets = target.insets();
215 Dimension targetDim = target.size();
216 int maxHeight = targetDim.height - (insets.top + insets.bottom + vVGap*2);
217 int x = insets.left + vHGap;
218 int y = 0;
219 int colWidth = 0;
220 int start = 0;
221
222 int n = target.countComponents();
223 for (int i = 0; i < n; i++) {
224 Component c = target.getComponent(i);
225 if (c.isVisible()) {
226 Dimension cDim = c.preferredSize();
227 c.resize(cDim.width, cDim.height);
228
229 if ((y == 0) || ((y + cDim.height) <= maxHeight)) {
230 if (y > 0) {
231 y += vVGap;
232 }
233 y += cDim.height;
234 colWidth = Math.max(colWidth, cDim.width);
235 }
236 else {
237 moveComponents(target,
238 x,
239 insets.top + vVGap,
240 colWidth,
241 maxHeight - y,
242 start,
243 i);
244 x += vHGap + colWidth;
245 y = cDim.width;
246 colWidth = cDim.width;
247 start = i;
248 }
249 }
250 }
251
252 moveComponents(target,
253 x,
254 insets.top + vVGap,
255 colWidth,
256 maxHeight - y,
257 start,
258 n);
259 }
260 }
261
262 /**
263 * Aligns the components vertically if there is any slack.
264 *
265 * @param target the container whose components need to be moved.
266 * @param x the x coordinate.
267 * @param y the y coordinate.
268 * @param width the width available.
269 * @param height the height available.
270 * @param colStart the beginning of the column.
271 * @param colEnd the end of the column.
272 */
273 private void moveComponents(Container target, int x, int y, int width, int height, int colStart, int colEnd) {
274 switch (vAlign) {
275 case TOP:
276 break;
277 case CENTER:
278 y += height/2;
279 break;
280 case BOTTOM:
281 y += height;
282 }
283
284 for (int i = colStart; i < colEnd; i++) {
285 Component c = target.getComponent(i);
286 Dimension cDim = c.size();
287 if (c.isVisible()) {
288 c.move(x + (width - cDim.width)/2, y);
289 y += vVGap + cDim.height;
290 }
291 }
292 }
293
294 /**
295 * Returns the String representation of this layout's values.
296 */
297 public String toString() {
298 String str = "";
299 switch (orientation) {
300 case HORIZONTAL:
301 str = "orientation=horizontal, ";
302 break;
303 case VERTICAL:
304 str = "orientation=vertical, ";
305 break;
306 }
307
308 return getClass().getName() + "[" + str + super.toString() + "]";
309 }
310 }