1 /* BorderLayout.java -- A layout manager class
2 Copyright (C) 1999, 2002 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. */
42 * This class implements a layout manager that positions components
43 * in certain sectors of the parent container.
45 * @author Aaron M. Renn (arenn@urbanophile.com)
46 * @author Rolf W. Rasmussen <rolfwr@ii.uib.no>
48 public class BorderLayout
implements LayoutManager2
, java
.io
.Serializable
56 * Constant indicating the top of the container
58 public static final String NORTH
= "North";
61 * Constant indicating the bottom of the container
63 public static final String SOUTH
= "South";
66 * Constant indicating the right side of the container
68 public static final String EAST
= "East";
71 * Constant indicating the left side of the container
73 public static final String WEST
= "West";
76 * Constant indicating the center of the container
78 public static final String CENTER
= "Center";
82 * The constant indicating the position before the first line of the
83 * layout. The exact position depends on the writing system: For a
84 * top-to-bottom orientation, it is the same as {@link #NORTH}, for
85 * a bottom-to-top orientation, it is the same as {@link #SOUTH}.
87 * <p>This constant is an older name for {@link #PAGE_START} which
88 * has exactly the same value.
92 public static final String BEFORE_FIRST_LINE
= "First";
96 * The constant indicating the position after the last line of the
97 * layout. The exact position depends on the writing system: For a
98 * top-to-bottom orientation, it is the same as {@link #SOUTH}, for
99 * a bottom-to-top orientation, it is the same as {@link #NORTH}.
101 * <p>This constant is an older name for {@link #PAGE_END} which
102 * has exactly the same value.
106 public static final String AFTER_LAST_LINE
= "Last";
110 * The constant indicating the position before the first item of the
111 * layout. The exact position depends on the writing system: For a
112 * left-to-right orientation, it is the same as {@link #WEST}, for
113 * a right-to-left orientation, it is the same as {@link #EAST}.
115 * <p>This constant is an older name for {@link #LINE_START} which
116 * has exactly the same value.
120 public static final String BEFORE_LINE_BEGINS
= "Before";
124 * The constant indicating the position after the last item of the
125 * layout. The exact position depends on the writing system: For a
126 * left-to-right orientation, it is the same as {@link #EAST}, for
127 * a right-to-left orientation, it is the same as {@link #WEST}.
129 * <p>This constant is an older name for {@link #LINE_END} which
130 * has exactly the same value.
134 public static final String AFTER_LINE_ENDS
= "After";
138 * The constant indicating the position before the first line of the
139 * layout. The exact position depends on the writing system: For a
140 * top-to-bottom orientation, it is the same as {@link #NORTH}, for
141 * a bottom-to-top orientation, it is the same as {@link #SOUTH}.
145 public static final String PAGE_START
= BEFORE_FIRST_LINE
;
149 * The constant indicating the position after the last line of the
150 * layout. The exact position depends on the writing system: For a
151 * top-to-bottom orientation, it is the same as {@link #SOUTH}, for
152 * a bottom-to-top orientation, it is the same as {@link #NORTH}.
156 public static final String PAGE_END
= AFTER_LAST_LINE
;
160 * The constant indicating the position before the first item of the
161 * layout. The exact position depends on the writing system: For a
162 * left-to-right orientation, it is the same as {@link #WEST}, for
163 * a right-to-left orientation, it is the same as {@link #EAST}.
167 public static final String LINE_START
= BEFORE_LINE_BEGINS
;
171 * The constant indicating the position after the last item of the
172 * layout. The exact position depends on the writing system: For a
173 * left-to-right orientation, it is the same as {@link #EAST}, for
174 * a right-to-left orientation, it is the same as {@link #WEST}.
178 public static final String LINE_END
= AFTER_LINE_ENDS
;
182 // Serialization constant
183 private static final long serialVersionUID
= -8658291919501921765L;
185 /*************************************************************************/
194 private Component north
;
199 private Component south
;
204 private Component east
;
209 private Component west
;
214 private Component center
;
219 private Component firstLine
;
224 private Component lastLine
;
229 private Component firstItem
;
234 private Component lastItem
;
237 * @serial The horizontal gap between components
242 * @serial The vertical gap between components
246 /*************************************************************************/
253 * Initializes a new instance of <code>BorderLayout</code> with no
254 * horiztonal or vertical gaps between components.
262 /*************************************************************************/
265 * Initializes a new instance of <code>BorderLayout</code> with the
266 * specified horiztonal and vertical gaps between components.
268 * @param hgap The horizontal gap between components.
269 * @param vgap The vertical gap between components.
272 BorderLayout(int hgap
, int vgap
)
278 /*************************************************************************/
285 * Returns the horitzontal gap value.
287 * @return The horitzontal gap value.
295 /*************************************************************************/
298 * Sets the horizontal gap to the specified value.
300 * @param hgap The new horizontal gap.
308 /*************************************************************************/
311 * Returns the vertical gap value.
313 * @return The vertical gap value.
321 /*************************************************************************/
324 * Sets the vertical gap to the specified value.
326 * @param vgap The new vertical gap value.
334 /*************************************************************************/
337 * Adds a component to the layout in the specified constraint position,
338 * which must be one of the string constants defined in this class.
340 * @param component The component to add.
341 * @param constraints The constraint string.
343 * @exception IllegalArgumentException If the constraint object is not
344 * a string, or is not one of the specified constants in this class.
347 addLayoutComponent(Component component
, Object constraints
)
349 if (constraints
!= null && ! (constraints
instanceof String
))
350 throw new IllegalArgumentException("Constraint must be a string");
352 String str
= (String
)constraints
;
354 if (str
== null || str
.equals(CENTER
))
356 else if (str
.equals(NORTH
))
358 else if (str
.equals(SOUTH
))
360 else if (str
.equals(EAST
))
362 else if (str
.equals(WEST
))
364 else if (str
.equals(BEFORE_FIRST_LINE
))
365 firstLine
= component
;
366 else if (str
.equals(AFTER_LAST_LINE
))
367 lastLine
= component
;
368 else if (str
.equals(BEFORE_LINE_BEGINS
))
369 firstItem
= component
;
370 else if (str
.equals(AFTER_LINE_ENDS
))
371 lastItem
= component
;
373 throw new IllegalArgumentException("Constraint value not valid: " + str
);
376 /*************************************************************************/
379 * Adds a component to the layout in the specified constraint position,
380 * which must be one of the string constants defined in this class.
382 * @param constraints The constraint string.
383 * @param component The component to add.
385 * @exception IllegalArgumentException If the constraint object is not
386 * one of the specified constants in this class.
388 * @deprecated This method is deprecated in favor of
389 * <code>addLayoutComponent(Component, Object)</code>.
392 addLayoutComponent(String constraints
, Component component
)
394 addLayoutComponent(component
, constraints
);
397 /*************************************************************************/
400 * Removes the specified component from the layout.
402 * @param component The component to remove from the layout.
405 removeLayoutComponent(Component component
)
407 if (north
== component
)
409 if (south
== component
)
411 if (east
== component
)
413 if (west
== component
)
415 if (center
== component
)
417 if (firstItem
== component
)
419 if (lastItem
== component
)
421 if (firstLine
== component
)
423 if (lastLine
== component
)
427 /*************************************************************************/
430 * Returns the minimum size of the specified container using this layout.
432 * @param target The container to calculate the minimum size for.
434 * @return The minimum size of the container
437 minimumLayoutSize(Container target
)
439 return calcSize(target
, MIN
);
442 /*************************************************************************/
445 * Returns the preferred size of the specified container using this layout.
447 * @param target The container to calculate the preferred size for.
449 * @return The preferred size of the container
452 preferredLayoutSize(Container target
)
454 return calcSize(target
, PREF
);
457 /*************************************************************************/
460 * Returns the maximum size of the specified container using this layout.
462 * @param target The container to calculate the maximum size for.
464 * @return The maximum size of the container
467 maximumLayoutSize(Container target
)
469 return calcSize(target
, MAX
);
472 /*************************************************************************/
475 * Returns the X axis alignment, which is a <code>float</code> indicating
476 * where along the X axis this container wishs to position its layout.
477 * 0 indicates align to the left, 1 indicates align to the right, and 0.5
478 * indicates align to the center.
480 * @param parent The parent container.
482 * @return The X alignment value.
485 getLayoutAlignmentX(Container parent
)
487 return(parent
.getAlignmentX());
490 /*************************************************************************/
493 * Returns the Y axis alignment, which is a <code>float</code> indicating
494 * where along the Y axis this container wishs to position its layout.
495 * 0 indicates align to the top, 1 indicates align to the bottom, and 0.5
496 * indicates align to the center.
498 * @param parent The parent container.
500 * @return The Y alignment value.
503 getLayoutAlignmentY(Container parent
)
505 return(parent
.getAlignmentY());
508 /*************************************************************************/
511 * Instructs this object to discard any layout information it might
514 * @param parent The parent container.
517 invalidateLayout(Container parent
)
521 /*************************************************************************/
524 * Lays out the specified container according to the constraints
527 * @param target The container to lay out.
530 layoutContainer(Container target
)
532 synchronized (target
.getTreeLock ())
534 Insets i
= target
.getInsets();
536 ComponentOrientation orient
= target
.getComponentOrientation ();
537 boolean left_to_right
= orient
.isLeftToRight ();
539 Component my_north
= north
;
540 Component my_east
= east
;
541 Component my_south
= south
;
542 Component my_west
= west
;
544 // Note that we currently don't handle vertical layouts. Neither
546 if (firstLine
!= null)
547 my_north
= firstLine
;
548 if (lastLine
!= null)
550 if (firstItem
!= null)
557 if (lastItem
!= null)
565 Dimension c
= calcCompSize(center
, PREF
);
566 Dimension n
= calcCompSize(my_north
, PREF
);
567 Dimension s
= calcCompSize(my_south
, PREF
);
568 Dimension e
= calcCompSize(my_east
, PREF
);
569 Dimension w
= calcCompSize(my_west
, PREF
);
570 Dimension t
= target
.getSize();
574 +----------------------------+ }
576 | +----------------------+ | --- y1 }
578 | +----------------------+ | } vgap
579 | +---+ +----------+ +---+ | --- y2 } }
580 | |w | |c | |e | | } hh
581 | +---+ +----------+ +---+ | } vgap }
582 | +----------------------+ | --- y3 }
584 | +----------------------+ | }
586 +----------------------------+ }
588 <---------------------->
594 int x2
= x1
+ w
.width
+ hgap
;
595 int x3
= t
.width
- i
.right
- e
.width
;
596 int ww
= t
.width
- i
.right
- i
.left
;
599 int y2
= y1
+ n
.height
+ vgap
;
600 int y3
= t
.height
- i
.bottom
- s
.height
;
603 setBounds(center
, x2
, y2
, x3
-x2
-hgap
, hh
);
604 setBounds(my_north
, x1
, y1
, ww
, n
.height
);
605 setBounds(my_south
, x1
, y3
, ww
, s
.height
);
606 setBounds(my_west
, x1
, y2
, w
.width
, hh
);
607 setBounds(my_east
, x3
, y2
, e
.width
, hh
);
611 /*************************************************************************/
614 * Returns a string representation of this layout manager.
616 * @return A string representation of this object.
621 return getClass().getName() + "[hgap=" + hgap
+ ",vgap=" + vgap
+ "]";
625 setBounds(Component comp
, int x
, int y
, int w
, int h
)
629 comp
.setBounds(x
, y
, w
, h
);
632 // Some constants for use with calcSize().
633 private static final int MIN
= 0;
634 private static final int MAX
= 1;
635 private static final int PREF
= 2;
638 calcCompSize(Component comp
, int what
)
641 return new Dimension(0, 0);
643 return comp
.getMinimumSize();
644 else if (what
== MAX
)
645 return comp
.getMaximumSize();
646 return comp
.getPreferredSize();
649 // This is a helper function used to compute the various sizes for
652 calcSize(Container target
, int what
)
654 synchronized (target
.getTreeLock ())
656 Insets ins
= target
.getInsets();
658 ComponentOrientation orient
= target
.getComponentOrientation ();
659 boolean left_to_right
= orient
.isLeftToRight ();
661 Component my_north
= north
;
662 Component my_east
= east
;
663 Component my_south
= south
;
664 Component my_west
= west
;
666 // Note that we currently don't handle vertical layouts. Neither
668 if (firstLine
!= null)
669 my_north
= firstLine
;
670 if (lastLine
!= null)
672 if (firstItem
!= null)
679 if (lastItem
!= null)
687 Dimension ndim
= calcCompSize(my_north
, what
);
688 Dimension sdim
= calcCompSize(my_south
, what
);
689 Dimension edim
= calcCompSize(my_east
, what
);
690 Dimension wdim
= calcCompSize(my_west
, what
);
691 Dimension cdim
= calcCompSize(center
, what
);
693 int width
= edim
.width
+ cdim
.width
+ wdim
.width
+ (hgap
* 2);
694 if (ndim
.width
> width
)
696 if (sdim
.width
> width
)
699 width
+= (ins
.left
+ ins
.right
);
701 int height
= edim
.height
;
702 if (cdim
.height
> height
)
703 height
= cdim
.height
;
704 if (wdim
.height
> height
)
705 height
= wdim
.height
;
707 height
+= (ndim
.height
+ sdim
.height
+ (vgap
* 2) + ins
.top
+ ins
.bottom
);
709 return(new Dimension(width
, height
));
712 } // class BorderLayout