From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/classpath/java/awt/BorderLayout.java | 742 +++++++++++++++++++++++++++ 1 file changed, 742 insertions(+) create mode 100644 libjava/classpath/java/awt/BorderLayout.java (limited to 'libjava/classpath/java/awt/BorderLayout.java') diff --git a/libjava/classpath/java/awt/BorderLayout.java b/libjava/classpath/java/awt/BorderLayout.java new file mode 100644 index 000000000..c06eb834b --- /dev/null +++ b/libjava/classpath/java/awt/BorderLayout.java @@ -0,0 +1,742 @@ +/* BorderLayout.java -- A layout manager class + Copyright (C) 1999, 2002, 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package java.awt; + + +/** + * This class implements a layout manager that positions components + * in certain sectors of the parent container. + * + * @author Aaron M. Renn (arenn@urbanophile.com) + * @author Rolf W. Rasmussen (rolfwr@ii.uib.no) + */ +public class BorderLayout implements LayoutManager2, java.io.Serializable +{ + + /** + * Constant indicating the top of the container + */ + public static final String NORTH = "North"; + + /** + * Constant indicating the bottom of the container + */ + public static final String SOUTH = "South"; + + /** + * Constant indicating the right side of the container + */ + public static final String EAST = "East"; + + /** + * Constant indicating the left side of the container + */ + public static final String WEST = "West"; + + /** + * Constant indicating the center of the container + */ + public static final String CENTER = "Center"; + + + /** + * The constant indicating the position before the first line of the + * layout. The exact position depends on the writing system: For a + * top-to-bottom orientation, it is the same as {@link #NORTH}, for + * a bottom-to-top orientation, it is the same as {@link #SOUTH}. + * + *

This constant is an older name for {@link #PAGE_START} which + * has exactly the same value. + * + * @since 1.2 + */ + public static final String BEFORE_FIRST_LINE = "First"; + + /** + * The constant indicating the position after the last line of the + * layout. The exact position depends on the writing system: For a + * top-to-bottom orientation, it is the same as {@link #SOUTH}, for + * a bottom-to-top orientation, it is the same as {@link #NORTH}. + * + *

This constant is an older name for {@link #PAGE_END} which + * has exactly the same value. + * + * @since 1.2 + */ + public static final String AFTER_LAST_LINE = "Last"; + + /** + * The constant indicating the position before the first item of the + * layout. The exact position depends on the writing system: For a + * left-to-right orientation, it is the same as {@link #WEST}, for + * a right-to-left orientation, it is the same as {@link #EAST}. + * + *

This constant is an older name for {@link #LINE_START} which + * has exactly the same value. + * + * @since 1.2 + */ + public static final String BEFORE_LINE_BEGINS = "Before"; + + /** + * The constant indicating the position after the last item of the + * layout. The exact position depends on the writing system: For a + * left-to-right orientation, it is the same as {@link #EAST}, for + * a right-to-left orientation, it is the same as {@link #WEST}. + * + *

This constant is an older name for {@link #LINE_END} which + * has exactly the same value. + * + * @since 1.2 + */ + public static final String AFTER_LINE_ENDS = "After"; + + /** + * The constant indicating the position before the first line of the + * layout. The exact position depends on the writing system: For a + * top-to-bottom orientation, it is the same as {@link #NORTH}, for + * a bottom-to-top orientation, it is the same as {@link #SOUTH}. + * + * @since 1.4 + */ + public static final String PAGE_START = BEFORE_FIRST_LINE; + + /** + * The constant indicating the position after the last line of the + * layout. The exact position depends on the writing system: For a + * top-to-bottom orientation, it is the same as {@link #SOUTH}, for + * a bottom-to-top orientation, it is the same as {@link #NORTH}. + * + * @since 1.4 + */ + public static final String PAGE_END = AFTER_LAST_LINE; + + /** + * The constant indicating the position before the first item of the + * layout. The exact position depends on the writing system: For a + * left-to-right orientation, it is the same as {@link #WEST}, for + * a right-to-left orientation, it is the same as {@link #EAST}. + * + * @since 1.4 + */ + public static final String LINE_START = BEFORE_LINE_BEGINS; + + /** + * The constant indicating the position after the last item of the + * layout. The exact position depends on the writing system: For a + * left-to-right orientation, it is the same as {@link #EAST}, for + * a right-to-left orientation, it is the same as {@link #WEST}. + * + * @since 1.4 + */ + public static final String LINE_END = AFTER_LINE_ENDS; + + + /** + * Serialization constant. + */ + private static final long serialVersionUID = -8658291919501921765L; + + + /** + * @serial + */ + private Component north; + + /** + * @serial + */ + private Component south; + + /** + * @serial + */ + private Component east; + + /** + * @serial + */ + private Component west; + + /** + * @serial + */ + private Component center; + + /** + * @serial + */ + private Component firstLine; + + /** + * @serial + */ + private Component lastLine; + + /** + * @serial + */ + private Component firstItem; + + /** + * @serial + */ + private Component lastItem; + + /** + * @serial The horizontal gap between components + */ + private int hgap; + + /** + * @serial The vertical gap between components + */ + private int vgap; + + + // Some constants for use with calcSize(). + private static final int MIN = 0; + private static final int MAX = 1; + private static final int PREF = 2; + + + /** + * Initializes a new instance of BorderLayout with no + * horiztonal or vertical gaps between components. + */ + public BorderLayout() + { + this(0,0); + } + + /** + * Initializes a new instance of BorderLayout with the + * specified horiztonal and vertical gaps between components. + * + * @param hgap The horizontal gap between components. + * @param vgap The vertical gap between components. + */ + public BorderLayout(int hgap, int vgap) + { + this.hgap = hgap; + this.vgap = vgap; + } + + /** + * Returns the horitzontal gap value. + * + * @return The horitzontal gap value. + */ + public int getHgap() + { + return(hgap); + } + + /** + * Sets the horizontal gap to the specified value. + * + * @param hgap The new horizontal gap. + */ + public void setHgap(int hgap) + { + this.hgap = hgap; + } + + /** + * Returns the vertical gap value. + * + * @return The vertical gap value. + */ + public int getVgap() + { + return(vgap); + } + + /** + * Sets the vertical gap to the specified value. + * + * @param vgap The new vertical gap value. + */ + public void setVgap(int vgap) + { + this.vgap = vgap; + } + + /** + * Adds a component to the layout in the specified constraint position, + * which must be one of the string constants defined in this class. + * + * @param component The component to add. + * @param constraints The constraint string. + * + * @exception IllegalArgumentException If the constraint object is not + * a string, or is not one of the specified constants in this class. + */ + public void addLayoutComponent(Component component, Object constraints) + { + if (constraints != null && ! (constraints instanceof String)) + throw new IllegalArgumentException("Constraint must be a string"); + + addLayoutComponent((String) constraints, component); + } + + /** + * Adds a component to the layout in the specified constraint position, + * which must be one of the string constants defined in this class. + * + * @param constraints The constraint string. + * @param component The component to add. + * + * @exception IllegalArgumentException If the constraint object is not + * one of the specified constants in this class. + * + * @deprecated This method is deprecated in favor of + * addLayoutComponent(Component, Object). + */ + public void addLayoutComponent(String constraints, Component component) + { + String str = constraints; + + if (str == null || str.equals(CENTER)) + center = component; + else if (str.equals(NORTH)) + north = component; + else if (str.equals(SOUTH)) + south = component; + else if (str.equals(EAST)) + east = component; + else if (str.equals(WEST)) + west = component; + else if (str.equals(BEFORE_FIRST_LINE)) + firstLine = component; + else if (str.equals(AFTER_LAST_LINE)) + lastLine = component; + else if (str.equals(BEFORE_LINE_BEGINS)) + firstItem = component; + else if (str.equals(AFTER_LINE_ENDS)) + lastItem = component; + else + throw new IllegalArgumentException("Constraint value not valid: " + str); + } + + /** + * Removes the specified component from the layout. + * + * @param component The component to remove from the layout. + */ + public void removeLayoutComponent(Component component) + { + if (north == component) + north = null; + if (south == component) + south = null; + if (east == component) + east = null; + if (west == component) + west = null; + if (center == component) + center = null; + if (firstItem == component) + firstItem = null; + if (lastItem == component) + lastItem = null; + if (firstLine == component) + firstLine = null; + if (lastLine == component) + lastLine = null; + } + + /** + * Returns the minimum size of the specified container using this layout. + * + * @param target The container to calculate the minimum size for. + * + * @return The minimum size of the container + */ + public Dimension minimumLayoutSize(Container target) + { + return calcSize(target, MIN); + } + + /** + * Returns the preferred size of the specified container using this layout. + * + * @param target The container to calculate the preferred size for. + * + * @return The preferred size of the container + */ + public Dimension preferredLayoutSize(Container target) + { + return calcSize(target, PREF); + } + + /** + * Returns the maximum size of the specified container using this layout. + * + * @param target The container to calculate the maximum size for. + * + * @return The maximum size of the container + */ + public Dimension maximumLayoutSize(Container target) + { + return new Dimension (Integer.MAX_VALUE, Integer.MAX_VALUE); + } + + /** + * Returns the X axis alignment, which is a float indicating + * where along the X axis this container wishs to position its layout. + * 0 indicates align to the left, 1 indicates align to the right, and 0.5 + * indicates align to the center. + * + * @param parent The parent container. + * + * @return The X alignment value. + */ + public float getLayoutAlignmentX(Container parent) + { + return 0.5F; + } + + /** + * Returns the Y axis alignment, which is a float indicating + * where along the Y axis this container wishs to position its layout. + * 0 indicates align to the top, 1 indicates align to the bottom, and 0.5 + * indicates align to the center. + * + * @param parent The parent container. + * + * @return The Y alignment value. + */ + public float getLayoutAlignmentY(Container parent) + { + return 0.5F; + } + + /** + * Instructs this object to discard any layout information it might + * have cached. + * + * @param parent The parent container. + */ + public void invalidateLayout(Container parent) + { + // Nothing to do here. + } + + /** + * Lays out the specified container according to the constraints in this + * object. + * + * @param target The container to lay out. + */ + public void layoutContainer(Container target) + { + synchronized (target.getTreeLock()) + { + Insets i = target.getInsets(); + int top = i.top; + int bottom = target.height - i.bottom; + int left = i.left; + int right = target.width - i.right; + + boolean left_to_right = target.getComponentOrientation().isLeftToRight(); + + Component my_north = north; + Component my_east = east; + Component my_south = south; + Component my_west = west; + + // Note that we currently don't handle vertical layouts. + // Neither does JDK 1.3. + if (firstLine != null) + my_north = firstLine; + if (lastLine != null) + my_south = lastLine; + if (firstItem != null) + { + if (left_to_right) + my_west = firstItem; + else + my_east = firstItem; + } + if (lastItem != null) + { + if (left_to_right) + my_east = lastItem; + else + my_west = lastItem; + } + + if (my_north != null) + { + Dimension n = calcCompSize(my_north, PREF); + my_north.setBounds(left, top, right - left, n.height); + top += n.height + vgap; + } + + if (my_south != null) + { + Dimension s = calcCompSize(my_south, PREF); + my_south.setBounds(left, bottom - s.height, right - left, s.height); + bottom -= s.height + vgap; + } + + if (my_east != null) + { + Dimension e = calcCompSize(my_east, PREF); + my_east.setBounds(right - e.width, top, e.width, bottom - top); + right -= e.width + hgap; + } + + if (my_west != null) + { + Dimension w = calcCompSize(my_west, PREF); + my_west.setBounds(left, top, w.width, bottom - top); + left += w.width + hgap; + } + + if (center != null) + center.setBounds(left, top, right - left, bottom - top); + } + } + + /** + * Returns a string representation of this layout manager. + * + * @return A string representation of this object. + */ + public String toString() + { + return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]"; + } + + private Dimension calcCompSize(Component comp, int what) + { + if (comp == null || ! comp.isVisible()) + return new Dimension(0, 0); + if (what == MIN) + return comp.getMinimumSize(); + else if (what == MAX) + return comp.getMaximumSize(); + return comp.getPreferredSize(); + } + + /** + * This is a helper function used to compute the various sizes for this + * layout. + */ + private Dimension calcSize(Container target, int what) + { + synchronized (target.getTreeLock()) + { + Insets ins = target.getInsets(); + + ComponentOrientation orient = target.getComponentOrientation (); + boolean left_to_right = orient.isLeftToRight (); + + Component my_north = north; + Component my_east = east; + Component my_south = south; + Component my_west = west; + + // Note that we currently don't handle vertical layouts. Neither + // does JDK 1.3. + if (firstLine != null) + my_north = firstLine; + if (lastLine != null) + my_south = lastLine; + if (firstItem != null) + { + if (left_to_right) + my_west = firstItem; + else + my_east = firstItem; + } + if (lastItem != null) + { + if (left_to_right) + my_east = lastItem; + else + my_west = lastItem; + } + + Dimension ndim = calcCompSize(my_north, what); + Dimension sdim = calcCompSize(my_south, what); + Dimension edim = calcCompSize(my_east, what); + Dimension wdim = calcCompSize(my_west, what); + Dimension cdim = calcCompSize(center, what); + + int width = edim.width + cdim.width + wdim.width + (hgap * 2); + // Check for overflow. + if (width < edim.width || width < cdim.width || width < cdim.width) + width = Integer.MAX_VALUE; + + if (ndim.width > width) + width = ndim.width; + if (sdim.width > width) + width = sdim.width; + + width += (ins.left + ins.right); + + int height = edim.height; + if (cdim.height > height) + height = cdim.height; + if (wdim.height > height) + height = wdim.height; + + int addedHeight = height + (ndim.height + sdim.height + (vgap * 2) + + ins.top + ins.bottom); + // Check for overflow. + if (addedHeight < height) + height = Integer.MAX_VALUE; + else + height = addedHeight; + + return(new Dimension(width, height)); + } + } + + /** + * Return the component at the indicated location, or null if no component + * is at that location. The constraints argument must be one of the + * location constants specified by this class. + * @param constraints the location + * @return the component at that location, or null + * @throws IllegalArgumentException if the constraints argument is not + * recognized + * @since 1.5 + */ + public Component getLayoutComponent(Object constraints) + { + if (constraints == CENTER) + return center; + if (constraints == NORTH) + return north; + if (constraints == EAST) + return east; + if (constraints == SOUTH) + return south; + if (constraints == WEST) + return west; + if (constraints == PAGE_START) + return firstLine; + if (constraints == PAGE_END) + return lastLine; + if (constraints == LINE_START) + return firstItem; + if (constraints == LINE_END) + return lastItem; + throw new IllegalArgumentException("constraint " + constraints + + " is not recognized"); + } + + /** + * Return the component at the specified location, which must be one + * of the absolute constants such as CENTER or SOUTH. The container's + * orientation is used to map this location to the correct corresponding + * component, so for instance in a right-to-left container, a request + * for the EAST component could return the LINE_END component. This will + * return null if no component is available at the given location. + * @param container the container whose orientation is used + * @param constraints the absolute location of the component + * @return the component at the location, or null + * @throws IllegalArgumentException if the constraint is not recognized + */ + public Component getLayoutComponent(Container container, Object constraints) + { + ComponentOrientation orient = container.getComponentOrientation(); + if (constraints == CENTER) + return center; + // Note that we don't support vertical layouts. + if (constraints == NORTH) + return north; + if (constraints == SOUTH) + return south; + if (constraints == WEST) + { + // Note that relative layout takes precedence. + if (orient.isLeftToRight()) + return firstItem == null ? west : firstItem; + return lastItem == null ? west : lastItem; + } + if (constraints == EAST) + { + // Note that relative layout takes precedence. + if (orient.isLeftToRight()) + return lastItem == null ? east : lastItem; + return firstItem == null ? east : firstItem; + } + throw new IllegalArgumentException("constraint " + constraints + + " is not recognized"); + } + + /** + * Return the constraint corresponding to a component in this layout. + * If the component is null, or is not in this layout, returns null. + * Otherwise, this will return one of the constraint constants defined + * in this class. + * @param c the component + * @return the constraint, or null + * @since 1.5 + */ + public Object getConstraints(Component c) + { + if (c == null) + return null; + if (c == center) + return CENTER; + if (c == north) + return NORTH; + if (c == east) + return EAST; + if (c == south) + return SOUTH; + if (c == west) + return WEST; + if (c == firstLine) + return PAGE_START; + if (c == lastLine) + return PAGE_END; + if (c == firstItem) + return LINE_START; + if (c == lastItem) + return LINE_END; + return null; + } +} -- cgit v1.2.3