1 /* SpringLayout.java --
2 Copyright (C) 2004 Free Software Foundation, Inc.
4 This file is part of GNU Classpath.
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING. If not, write to the
18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
21 Linking this library statically or dynamically with other modules is
22 making a combined work based on this library. Thus, the terms and
23 conditions of the GNU General Public License cover the whole
26 As a special exception, the copyright holders of this library give you
27 permission to link this library with independent modules to produce an
28 executable, regardless of the license terms of these independent
29 modules, and to copy and distribute the resulting executable under
30 terms of your choice, provided that you also meet, for each linked
31 independent module, the terms and conditions of the license of that
32 module. An independent module is a module which is not derived from
33 or based on this library. If you modify this library, you may extend
34 this exception to your version of the library, but you are not
35 obligated to do so. If you do not wish to do so, delete this
36 exception statement from your version. */
41 import java
.awt
.Component
;
42 import java
.awt
.Container
;
43 import java
.awt
.Dimension
;
44 import java
.awt
.LayoutManager2
;
45 import java
.util
.HashMap
;
49 * A very flexible layout manager. Components are laid out by defining the
50 * relationships between them. The relationships are expressed as
51 * {@link Spring}s. You can attach a Spring for each edge of a component and
52 * link it to an edge of a different component. For example, you can say,
53 * the northern edge of component A should be attached to the southern edge
54 * of component B, and the space between them should be something between
55 * x and y pixels, and preferably z pixels.
56 * <p>While quite simple, this layout manager can be used to emulate most other
57 * layout managers, and can also be used to solve some layout problems, which
58 * would be hard to solve with other layout managers.</p>
60 * @author Roman Kennke (roman@ontographics.com)
62 public class SpringLayout
implements LayoutManager2
65 /** The right edge of a component. */
66 public static final String EAST
= "East";
68 /** The top edge of a component. */
69 public static final String NORTH
= "North";
71 /** The bottom edge of a component. */
72 public static final String SOUTH
= "South";
74 /** The left edge of a component. */
75 public static final String WEST
= "West";
77 /** maps components to their constraints. */
78 private Map constraintsMap
;
81 * The constraints that define the relationships between components.
82 * Each Constraints object can hold 4 Springs: one for each edge of the
83 * component. Additionally it can hold Springs for the components width
84 * and the components height. Since the height and width constraints are
85 * dependend on the other constraints, a component can be over-constraint.
86 * In this case (like when all of NORTH, SOUTH and HEIGHT are constraint),
87 * the values are adjusted, so that the mathematics still hold true.
89 * @author Roman Kennke (roman@ontographics.com)
91 public static class Constraints
94 // The constraints for each edge, and width and height.
95 /** The Spring for the left edge. */
98 /** The Spring for the upper edge. */
101 /** The Spring for the height. */
102 private Spring height
;
104 /** The Spring for the width. */
105 private Spring width
;
107 /** The Spring for the right edge. */
110 /** The Spring for the bottom edge. */
111 private Spring south
;
114 * Creates a new Constraints object.
115 * There is no constraint set.
119 x
= y
= height
= width
= east
= south
= null;
123 * Creates a new Constraints object.
125 * @param x the constraint for the left edge of the component.
126 * @param y the constraint for the upper edge of the component.
128 public Constraints(Spring x
, Spring y
)
132 width
= height
= east
= south
= null;
136 * Creates a new Constraints object.
138 * @param x the constraint for the left edge of the component.
139 * @param y the constraint for the upper edge of the component.
140 * @param width the constraint for the width of the component.
141 * @param height the constraint for the height of the component.
143 public Constraints(Spring x
, Spring y
, Spring width
, Spring height
)
148 this.height
= height
;
153 * Returns the constraint for the edge with the <code>edgeName</code>.
154 * This is expected to be one of
155 * {@link #EAST}, {@link #WEST}, {@link NORTH} or {@link SOUTH}.
157 * @param edgeName the name of the edge.
158 * @return the constraint for the specified edge.
160 public Spring
getConstraint(String edgeName
)
162 Spring retVal
= null;
163 if (edgeName
.equals(SpringLayout
.NORTH
))
165 else if (edgeName
.equals(SpringLayout
.WEST
))
167 else if (edgeName
.equals(SpringLayout
.SOUTH
))
170 if ((retVal
== null) && (y
!= null) && (height
!= null))
171 retVal
= Spring
.sum(y
, height
);
173 else if (edgeName
.equals(SpringLayout
.EAST
))
176 if ((retVal
== null) && (x
!= null) && (width
!= null))
177 retVal
= Spring
.sum(x
, width
);
184 * Returns the constraint for the height of the component.
186 * @return the height constraint.
188 public Spring
getHeight()
190 Spring retVal
= height
;
191 if ((retVal
== null) && (y
!= null) && (south
!= null))
193 retVal
= Spring
.sum(south
, Spring
.minus(y
));
199 * Returns the constraint for the width of the component.
201 * @return the width constraint.
203 public Spring
getWidth()
205 Spring retVal
= width
;
206 if ((retVal
== null) && (x
!= null) && (east
!= null))
208 retVal
= Spring
.sum(east
, Spring
.minus(x
));
214 * Returns the constraint for the left edge of the component.
216 * @return the left-edge constraint (== WEST).
221 if ((retVal
== null) && (width
!= null) && (east
!= null))
223 retVal
= Spring
.sum(east
, Spring
.minus(width
));
229 * Returns the constraint for the upper edge of the component.
231 * @return the upper-edge constraint (== NORTH).
236 if ((retVal
== null) && (height
!= null) && (south
!= null))
238 retVal
= Spring
.sum(south
, Spring
.minus(height
));
244 * Sets a constraint for the specified edge. If this leads to an
245 * over-constrained situation, the constraints get adjusted, so that
246 * the mathematics still hold true.
248 * @param edgeName the name of the edge, one of {@link #EAST},
249 * {@link #WEST}, {@link NORTH} or {@link SOUTH}.
250 * @param s the constraint to be set.
252 public void setConstraint(String edgeName
, Spring s
)
255 if (edgeName
.equals(SpringLayout
.WEST
))
258 if ((width
!= null) && (east
!= null))
259 width
= Spring
.sum(east
, Spring
.minus(x
));
261 else if (edgeName
.equals(SpringLayout
.NORTH
))
264 if ((height
!= null) && (south
!= null))
265 height
= Spring
.sum(south
, Spring
.minus(y
));
267 else if (edgeName
.equals(SpringLayout
.EAST
))
270 if ((x
!= null) && (width
!= null))
271 x
= Spring
.sum(east
, Spring
.minus(width
));
273 else if (edgeName
.equals(SpringLayout
.SOUTH
))
276 if ((height
!= null) && (y
!= null))
277 y
= Spring
.sum(south
, Spring
.minus(height
));
283 * Sets the height-constraint.
285 * @param s the constraint to be set.
287 public void setHeight(Spring s
)
290 if ((south
!= null) && (y
!= null))
291 south
= Spring
.sum(y
, height
);
296 * Sets the width-constraint.
298 * @param s the constraint to be set.
300 public void setWidth(Spring s
)
303 if ((east
!= null) && (x
!= null))
304 east
= Spring
.sum(x
, width
);
309 * Sets the WEST-constraint.
311 * @param s the constraint to be set.
313 public void setX(Spring s
)
316 if ((width
!= null) && (east
!= null))
317 width
= Spring
.sum(east
, Spring
.minus(x
));
322 * Sets the NORTH-constraint.
324 * @param s the constraint to be set.
326 public void setY(Spring s
)
329 if ((height
!= null) && (south
!= null))
330 height
= Spring
.sum(south
, Spring
.minus(y
));
336 * Creates a new SpringLayout.
338 public SpringLayout()
341 constraintsMap
= new HashMap();
345 * Adds a layout component and a constraint object to this layout.
346 * This method is usually only called by a {@java.awt.Container}s add
349 * @param component the component to be added.
350 * @param constraint the constraint to be set.
352 public void addLayoutComponent(Component component
, Object constraint
)
354 constraintsMap
.put(component
, constraint
);
359 * Adds a layout component and a constraint object to this layout.
360 * This method is usually only called by a {@java.awt.Container}s add
361 * Method. This method does nothing, since SpringLayout does not manage
362 * String-indexed components.
364 * @param component the component to be added.
365 * @param constraint the constraint to be set.
367 public void addLayoutComponent(String name
, Component c
)
373 * Returns the constraint of the edge named by <code>edgeName</code>.
375 * @param c the component from which to get the constraint.
376 * @param edgeName the name of the edge, one of {@link #EAST},
377 * {@link #WEST}, {@link NORTH} or {@link SOUTH}.
378 * @return the constraint of the edge <code>edgeName</code> of the
381 public Spring
getConstraint(String edgeName
, Component c
)
383 Constraints constraints
= getConstraints(c
);
384 return constraints
.getConstraint(edgeName
);
388 * Returns the {@link Constraints} object associated with the specified
391 * @param c the component for which to determine the constraint.
392 * @return the {@link Constraints} object associated with the specified
395 public SpringLayout
.Constraints
getConstraints(Component c
)
397 Constraints constraints
= (Constraints
) constraintsMap
.get(c
);
398 if (constraints
== null)
400 Container parent
= c
.getParent();
401 constraints
= new Constraints();
405 (Spring
.constant(parent
.getInsets().left
));
407 (Spring
.constant(parent
.getInsets().top
));
412 (Spring
.constant(0));
414 (Spring
.constant(0));
418 (Spring
.constant(c
.getMinimumSize().width
,
419 c
.getPreferredSize().width
,
420 c
.getMaximumSize().width
));
421 constraints
.setHeight
422 (Spring
.constant(c
.getMinimumSize().height
,
423 c
.getPreferredSize().height
,
424 c
.getMaximumSize().height
));
426 constraintsMap
.put(c
, constraints
);
434 * Returns the X alignment of the Container <code>p</code>.
436 * @param p the {@link java.awt.Container} for which to determine the X
440 public float getLayoutAlignmentX(Container p
)
446 * Returns the Y alignment of the Container <code>p</code>.
448 * @param p the {@link java.awt.Container} for which to determine the Y
452 public float getLayoutAlignmentY(Container p
)
458 * Recalculate a possibly cached layout.
460 public void invalidateLayout(Container p
)
462 // nothing to do here yet
466 * Lays out the container <code>p</code>.
468 * @param p the container to be laid out.
470 public void layoutContainer(Container p
)
473 addLayoutComponent(p
, new Constraints(Spring
.constant(0),
474 Spring
.constant(0)));
476 int offsetX
= p
.getInsets().left
;
477 int offsetY
= p
.getInsets().right
;
479 Component
[] components
= p
.getComponents();
480 for (int index
= 0; index
< components
.length
; index
++)
482 Component c
= components
[index
];
483 Constraints constraints
= getConstraints(c
);
484 int x
= constraints
.getX().getValue();
485 int y
= constraints
.getY().getValue();
486 int width
= constraints
.getWidth().getValue();
487 int height
= constraints
.getHeight().getValue();
489 c
.setLocation(x
+ offsetX
, y
+ offsetY
);
490 c
.setSize(width
, height
);
496 * Calculates the maximum size of the layed out container. This
497 * respects the maximum sizes of all contained components.
499 * @param p the container to be laid out.
500 * @return the maximum size of the container.
502 public Dimension
maximumLayoutSize(Container p
)
507 int offsetX
= p
.getInsets().left
;
508 int offsetY
= p
.getInsets().right
;
510 Component
[] components
= p
.getComponents();
511 for (int index
= 0; index
< components
.length
; index
++)
513 Component c
= components
[index
];
514 Constraints constraints
= getConstraints(c
);
515 int x
= constraints
.getX().getMaximumValue();
516 int y
= constraints
.getY().getMaximumValue();
517 int width
= constraints
.getWidth().getMaximumValue();
518 int height
= constraints
.getHeight().getMaximumValue();
520 int rightEdge
= offsetX
+ x
+ width
;
521 if (rightEdge
> maxX
)
523 int bottomEdge
= offsetY
+ y
+ height
;
524 if (bottomEdge
> maxY
)
528 return new Dimension(maxX
, maxY
);
533 * Calculates the minimum size of the layed out container. This
534 * respects the minimum sizes of all contained components.
536 * @param p the container to be laid out.
537 * @return the minimum size of the container.
539 public Dimension
minimumLayoutSize(Container p
)
544 int offsetX
= p
.getInsets().left
;
545 int offsetY
= p
.getInsets().right
;
547 Component
[] components
= p
.getComponents();
548 for (int index
= 0; index
< components
.length
; index
++)
550 Component c
= components
[index
];
551 Constraints constraints
= getConstraints(c
);
552 int x
= constraints
.getX().getMinimumValue();
553 int y
= constraints
.getY().getMinimumValue();
554 int width
= constraints
.getWidth().getMinimumValue();
555 int height
= constraints
.getHeight().getMinimumValue();
557 int rightEdge
= offsetX
+ x
+ width
;
558 if (rightEdge
> maxX
)
560 int bottomEdge
= offsetY
+ y
+ height
;
561 if (bottomEdge
> maxY
)
565 return new Dimension(maxX
, maxY
);
569 * Calculates the preferred size of the layed out container. This
570 * respects the preferred sizes of all contained components.
572 * @param p the container to be laid out.
573 * @return the preferred size of the container.
575 public Dimension
preferredLayoutSize(Container p
)
580 int offsetX
= p
.getInsets().left
;
581 int offsetY
= p
.getInsets().right
;
583 Component
[] components
= p
.getComponents();
584 for (int index
= 0; index
< components
.length
; index
++)
586 Component c
= components
[index
];
587 Constraints constraints
= getConstraints(c
);
588 int x
= constraints
.getX().getPreferredValue();
589 int y
= constraints
.getY().getPreferredValue();
590 int width
= constraints
.getWidth().getPreferredValue();
591 int height
= constraints
.getHeight().getPreferredValue();
593 int rightEdge
= offsetX
+ x
+ width
;
594 if (rightEdge
> maxX
)
596 int bottomEdge
= offsetY
+ y
+ height
;
597 if (bottomEdge
> maxY
)
601 return new Dimension(maxX
, maxY
);
605 * Attaches the edge <code>e1</code> of component <code>c1</code> to
606 * the edge <code>e2</code> of component <code>c2</code> width the
607 * fixed strut <code>pad</code>.
609 * @param e1 the edge of component 1.
610 * @param c1 the component 1.
611 * @param pad the space between the components in pixels.
612 * @param e2 the edge of component 2.
613 * @param c2 the component 2.
615 public void putConstraint(String e1
, Component c1
, int pad
, String e2
,
618 Constraints constraints1
= getConstraints(c1
);
619 Constraints constraints2
= getConstraints(c2
);
621 Spring strut
= Spring
.constant(pad
);
622 Spring otherEdge
= constraints2
.getConstraint(e2
);
623 constraints1
.setConstraint(e1
, Spring
.sum(strut
, otherEdge
));
628 * Attaches the edge <code>e1</code> of component <code>c1</code> to
629 * the edge <code>e2</code> of component <code>c2</code> width the
630 * {@link Spring} <code>s</code>.
632 * @param e1 the edge of component 1.
633 * @param c1 the component 1.
634 * @param s the space between the components as a {@link Spring} object.
635 * @param e2 the edge of component 2.
636 * @param c2 the component 2.
638 public void putConstraint(String e1
, Component c1
, Spring s
, String e2
,
641 Constraints constraints1
= getConstraints(c1
);
642 Constraints constraints2
= getConstraints(c2
);
644 Spring otherEdge
= constraints2
.getConstraint(e2
);
645 constraints1
.setConstraint(e1
, Spring
.sum(s
, otherEdge
));
650 * Removes a layout component.
651 * @param c the layout component to remove.
653 public void removeLayoutComponent(Component c
)