JDK14/Java14源码在线阅读
/*
* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.swing;
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FontMetrics;
import java.awt.Insets;
import java.awt.LayoutManager2;
import java.awt.Rectangle;
import java.util.*;
/**
* A <code>SpringLayout</code> lays out the children of its associated container
* according to a set of constraints.
* See <a href="https://docs.oracle.com/javase/tutorial/uiswing/layout/spring.html">How to Use SpringLayout</a>
* in <em>The Java Tutorial</em> for examples of using
* <code>SpringLayout</code>.
*
* <p>
* Each constraint,
* represented by a <code>Spring</code> object,
* controls the vertical or horizontal distance
* between two component edges.
* The edges can belong to
* any child of the container,
* or to the container itself.
* For example,
* the allowable width of a component
* can be expressed using a constraint
* that controls the distance between the west (left) and east (right)
* edges of the component.
* The allowable <em>y</em> coordinates for a component
* can be expressed by constraining the distance between
* the north (top) edge of the component
* and the north edge of its container.
*
* <P>
* Every child of a <code>SpringLayout</code>-controlled container,
* as well as the container itself,
* has exactly one set of constraints
* associated with it.
* These constraints are represented by
* a <code>SpringLayout.Constraints</code> object.
* By default,
* <code>SpringLayout</code> creates constraints
* that make their associated component
* have the minimum, preferred, and maximum sizes
* returned by the component's
* {@link java.awt.Component#getMinimumSize},
* {@link java.awt.Component#getPreferredSize}, and
* {@link java.awt.Component#getMaximumSize}
* methods. The <em>x</em> and <em>y</em> positions are initially not
* constrained, so that until you constrain them the <code>Component</code>
* will be positioned at 0,0 relative to the <code>Insets</code> of the
* parent <code>Container</code>.
*
* <p>
* You can change
* a component's constraints in several ways.
* You can
* use one of the
* {@link #putConstraint putConstraint}
* methods
* to establish a spring
* linking the edges of two components within the same container.
* Or you can get the appropriate <code>SpringLayout.Constraints</code>
* object using
* {@link #getConstraints getConstraints}
* and then modify one or more of its springs.
* Or you can get the spring for a particular edge of a component
* using {@link #getConstraint getConstraint},
* and modify it.
* You can also associate
* your own <code>SpringLayout.Constraints</code> object
* with a component by specifying the constraints object
* when you add the component to its container
* (using
* {@link Container#add(Component, Object)}).
*
* <p>
* The <code>Spring</code> object representing each constraint
* has a minimum, preferred, maximum, and current value.
* The current value of the spring
* is somewhere between the minimum and maximum values,
* according to the formula given in the
* {@link Spring#sum} method description.
* When the minimum, preferred, and maximum values are the same,
* the current value is always equal to them;
* this inflexible spring is called a <em>strut</em>.
* You can create struts using the factory method
* {@link Spring#constant(int)}.
* The <code>Spring</code> class also provides factory methods
* for creating other kinds of springs,
* including springs that depend on other springs.
*
* <p>
* In a <code>SpringLayout</code>, the position of each edge is dependent on
* the position of just one other edge. If a constraint is subsequently added
* to create a new binding for an edge, the previous binding is discarded
* and the edge remains dependent on a single edge.
* Springs should only be attached
* between edges of the container and its immediate children; the behavior
* of the <code>SpringLayout</code> when presented with constraints linking
* the edges of components from different containers (either internal or
* external) is undefined.
*
* <h2>
* SpringLayout vs. Other Layout Managers
* </h2>
*
* <blockquote>
* <hr>
* <strong>Note:</strong>
* Unlike many layout managers,
* <code>SpringLayout</code> doesn't automatically set the location of
* the components it manages.
* If you hand-code a GUI that uses <code>SpringLayout</code>,
* remember to initialize component locations by constraining the west/east
* and north/south locations.
* <p>
* Depending on the constraints you use,
* you may also need to set the size of the container explicitly.
* <hr>
* </blockquote>
*
* <p>
* Despite the simplicity of <code>SpringLayout</code>,
* it can emulate the behavior of most other layout managers.
* For some features,
* such as the line breaking provided by <code>FlowLayout</code>,
* you'll need to
* create a special-purpose subclass of the <code>Spring</code> class.
*
* <p>
* <code>SpringLayout</code> also provides a way to solve
* many of the difficult layout
* problems that cannot be solved by nesting combinations
* of <code>Box</code>es. That said, <code>SpringLayout</code> honors the
* <code>LayoutManager2</code> contract correctly and so can be nested with
* other layout managers -- a technique that can be preferable to
* creating the constraints implied by the other layout managers.
* <p>
* The asymptotic complexity of the layout operation of a <code>SpringLayout</code>
* is linear in the number of constraints (and/or components).
* <p>
* <strong>Warning:</strong>
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
* has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*
* @see Spring
* @see SpringLayout.Constraints
*
* @author Philip Milne
* @author Scott Violet
* @author Joe Winchester
* @since 1.4
*/
@SuppressWarnings("serial") // Same-version serialization only
public class SpringLayout implements LayoutManager2 {
private Map<Component, Constraints> componentConstraints = new HashMap<Component, Constraints>();
private Spring cyclicReference = Spring.constant(Spring.UNSET);
private Set<Spring> cyclicSprings;
private Set<Spring> acyclicSprings;
/**
* Specifies the top edge of a component's bounding rectangle.
*/
public static final String NORTH = "North";
/**
* Specifies the bottom edge of a component's bounding rectangle.
*/
public static final String SOUTH = "South";
/**
* Specifies the right edge of a component's bounding rectangle.
*/
public static final String EAST = "East";
/**
* Specifies the left edge of a component's bounding rectangle.
*/
public static final String WEST = "West";
/**
* Specifies the horizontal center of a component's bounding rectangle.
*
* @since 1.6
*/
public static final String HORIZONTAL_CENTER = "HorizontalCenter";
/**
* Specifies the vertical center of a component's bounding rectangle.
*
* @since 1.6
*/
public static final String VERTICAL_CENTER = "VerticalCenter";
/**
* Specifies the baseline of a component.
*
* @since 1.6
*/
public static final String BASELINE = "Baseline";
/**
* Specifies the width of a component's bounding rectangle.
*
* @since 1.6
*/
public static final String WIDTH = "Width";
/**
* Specifies the height of a component's bounding rectangle.
*
* @since 1.6
*/
public static final String HEIGHT = "Height";
private static String[] ALL_HORIZONTAL = {WEST, WIDTH, EAST, HORIZONTAL_CENTER};
private static String[] ALL_VERTICAL = {NORTH, HEIGHT, SOUTH, VERTICAL_CENTER, BASELINE};
/**
* A <code>Constraints</code> object holds the
* constraints that govern the way a component's size and position
* change in a container controlled by a <code>SpringLayout</code>.
* A <code>Constraints</code> object is
* like a <code>Rectangle</code>, in that it
* has <code>x</code>, <code>y</code>,
* <code>width</code>, and <code>height</code> properties.
* In the <code>Constraints</code> object, however,
* these properties have
* <code>Spring</code> values instead of integers.
* In addition,
* a <code>Constraints</code> object
* can be manipulated as four edges
* -- north, south, east, and west --
* using the <code>constraint</code> property.
*
* <p>
* The following formulas are always true
* for a <code>Constraints</code> object (here WEST and <code>x</code> are synonyms, as are and NORTH and <code>y</code>):
*
* <pre>
* EAST = WEST + WIDTH
* SOUTH = NORTH + HEIGHT
* HORIZONTAL_CENTER = WEST + WIDTH/2
* VERTICAL_CENTER = NORTH + HEIGHT/2
* ABSOLUTE_BASELINE = NORTH + RELATIVE_BASELINE*
* </pre>
* <p>
* For example, if you have specified the WIDTH and WEST (X) location
* the EAST is calculated as WEST + WIDTH. If you instead specified
* the WIDTH and EAST locations the WEST (X) location is then calculated
* as EAST - WIDTH.
* <p>
* [RELATIVE_BASELINE is a private constraint that is set automatically when
* the SpringLayout.Constraints(Component) constructor is called or when
* a constraints object is registered with a SpringLayout object.]
* <p>
* <b>Note</b>: In this document,
* operators represent methods
* in the <code>Spring</code> class.
* For example, "a + b" is equal to
* <code>Spring.sum(a, b)</code>,
* and "a - b" is equal to
* <code>Spring.sum(a, Spring.minus(b))</code>.
* See the
* {@link Spring Spring API documentation}
* for further details
* of spring arithmetic.
*
* <p>
*
* Because a <code>Constraints</code> object's properties --
* representing its edges, size, and location -- can all be set
* independently and yet are interrelated,
* a <code>Constraints</code> object can become <em>over-constrained</em>.
* For example, if the <code>WEST</code>, <code>WIDTH</code> and
* <code>EAST</code> edges are all set, steps must be taken to ensure that
* the first of the formulas above holds. To do this, the
* <code>Constraints</code>
* object throws away the <em>least recently set</em>
* constraint so as to make the formulas hold.
* @since 1.4
*/
public static class Constraints {
private Spring x;
private Spring y;
private Spring width;
private Spring height;
private Spring east;
private Spring south;
private Spring horizontalCenter;
private Spring verticalCenter;
private Spring baseline;
private List<String> horizontalHistory = new ArrayList<String>(2);
private List<String> verticalHistory = new ArrayList<String>(2);
// Used for baseline calculations
private Component c;
/**
* Creates an empty <code>Constraints</code> object.
*/
public Constraints() {
}
/**
* Creates a <code>Constraints</code> object with the
* specified values for its
* <code>x</code> and <code>y</code> properties.
* The <code>height</code> and <code>width</code> springs
* have <code>null</code> values.
*
* @param x the spring controlling the component's <em>x</em> value
* @param y the spring controlling the component's <em>y</em> value
*/
public Constraints(Spring x, Spring y) {
setX(x);
setY(y);
}
/**
* Creates a <code>Constraints</code> object with the
* specified values for its
* <code>x</code>, <code>y</code>, <code>width</code>,
* and <code>height</code> properties.
* Note: If the <code>SpringLayout</code> class
* encounters <code>null</code> values in the
* <code>Constraints</code> object of a given component,
* it replaces them with suitable defaults.
*
* @param x the spring value for the <code>x</code> property
* @param y the spring value for the <code>y</code> property
* @param width the spring value for the <code>width</code> property
* @param height the spring value for the <code>height</code> property
*/
public Constraints(Spring x, Spring y, Spring width, Spring height) {
setX(x);
setY(y);
setWidth(width);
setHeight(height);
}
/**
* Creates a <code>Constraints</code> object with
* suitable <code>x</code>, <code>y</code>, <code>width</code> and
* <code>height</code> springs for component, <code>c</code>.
* The <code>x</code> and <code>y</code> springs are constant
* springs initialised with the component's location at
* the time this method is called. The <code>width</code> and
* <code>height</code> springs are special springs, created by
* the <code>Spring.width()</code> and <code>Spring.height()</code>
* methods, which track the size characteristics of the component
* when they change.
*
* @param c the component whose characteristics will be reflected by this Constraints object
* @throws NullPointerException if <code>c</code> is null.
* @since 1.5
*/
public Constraints(Component c) {
this.c = c;
setX(Spring.constant(c.getX()));
setY(Spring.constant(c.getY()));
setWidth(Spring.width(c));
setHeight(Spring.height(c));
}
private void pushConstraint(String name, Spring value, boolean horizontal) {
boolean valid = true;
List<String> history = horizontal ? horizontalHistory :
verticalHistory;
if (history.contains(name)) {
history.remove(name);
valid = false;
} else if (history.size() == 2 && value != null) {
history.remove(0);
valid = false;
}
if (value != null) {
history.add(name);
}
if (!valid) {
String[] all = horizontal ? ALL_HORIZONTAL : ALL_VERTICAL;
for (String s : all) {
if (!history.contains(s)) {
setConstraint(s, null);
}
}
}
}
private Spring sum(Spring s1, Spring s2) {
return (s1 == null || s2 == null) ? null : Spring.sum(s1, s2);
}
private Spring difference(Spring s1, Spring s2) {
return (s1 == null || s2 == null) ? null : Spring.difference(s1, s2);
}
private Spring scale(Spring s, float factor) {
return (s == null) ? null : Spring.scale(s, factor);
}
private int getBaselineFromHeight(int height) {
if (height < 0) {
// Bad Scott, Bad Scott!
return -c.getBaseline(c.getPreferredSize().width,
-height);
}
return c.getBaseline(c.getPreferredSize().width, height);
}
private int getHeightFromBaseLine(int baseline) {
Dimension prefSize = c.getPreferredSize();
int prefHeight = prefSize.height;
int prefBaseline = c.getBaseline(prefSize.width, prefHeight);
if (prefBaseline == baseline) {
// If prefBaseline < 0, then no baseline, assume preferred
// height.
// If prefBaseline == baseline, then specified baseline
// matches preferred baseline, return preferred height
return prefHeight;
}
// Valid baseline
switch(c.getBaselineResizeBehavior()) {
case CONSTANT_DESCENT:
return prefHeight + (baseline - prefBaseline);
case CENTER_OFFSET:
return prefHeight + 2 * (baseline - prefBaseline);
case CONSTANT_ASCENT:
// Component baseline and specified baseline will NEVER
// match, fall through to default
default: // OTHER
// No way to map from baseline to height.
}
return Integer.MIN_VALUE;
}
private Spring heightToRelativeBaseline(Spring s) {
return new Spring.SpringMap(s) {
protected int map(int i) {
return getBaselineFromHeight(i);
}
protected int inv(int i) {
return getHeightFromBaseLine(i);
}
};
}
private Spring relativeBaselineToHeight(Spring s) {
return new Spring.SpringMap(s) {
protected int map(int i) {
return getHeightFromBaseLine(i);
}
protected int inv(int i) {
return getBaselineFromHeight(i);
}
};
}
private boolean defined(List<?> history, String s1, String s2) {
return history.contains(s1) && history.contains(s2);
}
/**
* Sets the <code>x</code> property,
* which controls the <code>x</code> value
* of a component's location.
*
* @param x the spring controlling the <code>x</code> value
* of a component's location
*
* @see #getX
* @see SpringLayout.Constraints
*/
public void setX(Spring x) {
this.x = x;
pushConstraint(WEST, x, true);
}
/**
* Returns the value of the <code>x</code> property.
*
* @return the spring controlling the <code>x</code> value
* of a component's location
*
* @see #setX
* @see SpringLayout.Constraints
*/
public Spring getX() {
if (x == null) {
if (defined(horizontalHistory, EAST, WIDTH)) {
x = difference(east, width);
} else if (defined(horizontalHistory, HORIZONTAL_CENTER, WIDTH)) {
x = difference(horizontalCenter, scale(width, 0.5f));
} else if (defined(horizontalHistory, HORIZONTAL_CENTER, EAST)) {
x = difference(scale(horizontalCenter, 2f), east);
}
}
return x;
}
/**
* Sets the <code>y</code> property,
* which controls the <code>y</code> value
* of a component's location.
*
* @param y the spring controlling the <code>y</code> value
* of a component's location
*
* @see #getY
* @see SpringLayout.Constraints
*/
public void setY(Spring y) {
this.y = y;
pushConstraint(NORTH, y, false);
}
/**
* Returns the value of the <code>y</code> property.
*
* @return the spring controlling the <code>y</code> value
* of a component's location
*
* @see #setY
* @see SpringLayout.Constraints
*/
public Spring getY() {
if (y == null) {
if (defined(verticalHistory, SOUTH, HEIGHT)) {
y = difference(south, height);
} else if (defined(verticalHistory, VERTICAL_CENTER, HEIGHT)) {
y = difference(verticalCenter, scale(height, 0.5f));
} else if (defined(verticalHistory, VERTICAL_CENTER, SOUTH)) {
y = difference(scale(verticalCenter, 2f), south);
} else if (defined(verticalHistory, BASELINE, HEIGHT)) {
y = difference(baseline, heightToRelativeBaseline(height));
} else if (defined(verticalHistory, BASELINE, SOUTH)) {
y = scale(difference(baseline, heightToRelativeBaseline(south)), 2f);
/*
} else if (defined(verticalHistory, BASELINE, VERTICAL_CENTER)) {
y = scale(difference(baseline, heightToRelativeBaseline(scale(verticalCenter, 2))), 1f/(1-2*0.5f));
*/
}
}
return y;
}
/**
* Sets the <code>width</code> property,
* which controls the width of a component.
*
* @param width the spring controlling the width of this
* <code>Constraints</code> object
*
* @see #getWidth
* @see SpringLayout.Constraints
*/
public void setWidth(Spring width) {
this.width = width;
pushConstraint(WIDTH, width, true);
}
/**
* Returns the value of the <code>width</code> property.
*
* @return the spring controlling the width of a component
*
* @see #setWidth
* @see SpringLayout.Constraints
*/
public Spring getWidth() {
if (width == null) {
if (horizontalHistory.contains(EAST)) {
width = difference(east, getX());
} else if (horizontalHistory.contains(HORIZONTAL_CENTER)) {
width = scale(difference(horizontalCenter, getX()), 2f);
}
}
return width;
}
/**
* Sets the <code>height</code> property,
* which controls the height of a component.
*
* @param height the spring controlling the height of this <code>Constraints</code>
* object
*
* @see #getHeight
* @see SpringLayout.Constraints
*/
public void setHeight(Spring height) {
this.height = height;
pushConstraint(HEIGHT, height, false);
}
/**
* Returns the value of the <code>height</code> property.
*
* @return the spring controlling the height of a component
*
* @see #setHeight
* @see SpringLayout.Constraints
*/
public Spring getHeight() {
if (height == null) {
if (verticalHistory.contains(SOUTH)) {
height = difference(south, getY());
} else if (verticalHistory.contains(VERTICAL_CENTER)) {
height = scale(difference(verticalCenter, getY()), 2f);
} else if (verticalHistory.contains(BASELINE)) {
height = relativeBaselineToHeight(difference(baseline, getY()));
}
}
return height;
}
private void setEast(Spring east) {
this.east = east;
pushConstraint(EAST, east, true);
}
private Spring getEast() {
if (east == null) {
east = sum(getX(), getWidth());
}
return east;
}
private void setSouth(Spring south) {
this.south = south;
pushConstraint(SOUTH, south, false);
}
private Spring getSouth() {
if (south == null) {
south = sum(getY(), getHeight());
}
return south;
}
private Spring getHorizontalCenter() {
if (horizontalCenter == null) {
horizontalCenter = sum(getX(), scale(getWidth(), 0.5f));
}
return horizontalCenter;
}
private void setHorizontalCenter(Spring horizontalCenter) {
this.horizontalCenter = horizontalCenter;
pushConstraint(HORIZONTAL_CENTER, horizontalCenter, true);
}
private Spring getVerticalCenter() {
if (verticalCenter == null) {
verticalCenter = sum(getY(), scale(getHeight(), 0.5f));
}
return verticalCenter;
}
private void setVerticalCenter(Spring verticalCenter) {
this.verticalCenter = verticalCenter;
pushConstraint(VERTICAL_CENTER, verticalCenter, false);
}
private Spring getBaseline() {
if (baseline == null) {
baseline = sum(getY(), heightToRelativeBaseline(getHeight()));
}
return baseline;
}
private void setBaseline(Spring baseline) {
this.baseline = baseline;
pushConstraint(BASELINE, baseline, false);
}
/**
* Sets the spring controlling the specified edge.
* The edge must have one of the following values:
* <code>SpringLayout.NORTH</code>,
* <code>SpringLayout.SOUTH</code>,
* <code>SpringLayout.EAST</code>,
* <code>SpringLayout.WEST</code>,
* <code>SpringLayout.HORIZONTAL_CENTER</code>,
* <code>SpringLayout.VERTICAL_CENTER</code>,
* <code>SpringLayout.BASELINE</code>,
* <code>SpringLayout.WIDTH</code> or
* <code>SpringLayout.HEIGHT</code>.
* For any other <code>String</code> value passed as the edge,
* no action is taken. For a <code>null</code> edge, a
* <code>NullPointerException</code> is thrown.
* <p>
* <b>Note:</b> This method can affect {@code x} and {@code y} values
* previously set for this {@code Constraints}.
*
* @param edgeName the edge to be set
* @param s the spring controlling the specified edge
*
* @throws NullPointerException if <code>edgeName</code> is <code>null</code>
*
* @see #getConstraint
* @see #NORTH
* @see #SOUTH
* @see #EAST
* @see #WEST
* @see #HORIZONTAL_CENTER
* @see #VERTICAL_CENTER
* @see #BASELINE
* @see #WIDTH
* @see #HEIGHT
* @see SpringLayout.Constraints
*/
public void setConstraint(String edgeName, Spring s) {
edgeName = edgeName.intern();
if (edgeName == WEST) {
setX(s);
} else if (edgeName == NORTH) {
setY(s);
} else if (edgeName == EAST) {
setEast(s);
} else if (edgeName == SOUTH) {
setSouth(s);
} else if (edgeName == HORIZONTAL_CENTER) {
setHorizontalCenter(s);
} else if (edgeName == WIDTH) {
setWidth(s);
} else if (edgeName == HEIGHT) {
setHeight(s);
} else if (edgeName == VERTICAL_CENTER) {
setVerticalCenter(s);
} else if (edgeName == BASELINE) {
setBaseline(s);
}
}
/**
* Returns the value of the specified edge, which may be
* a derived value, or even <code>null</code>.
* The edge must have one of the following values:
* <code>SpringLayout.NORTH</code>,
* <code>SpringLayout.SOUTH</code>,
* <code>SpringLayout.EAST</code>,
* <code>SpringLayout.WEST</code>,
* <code>SpringLayout.HORIZONTAL_CENTER</code>,
* <code>SpringLayout.VERTICAL_CENTER</code>,
* <code>SpringLayout.BASELINE</code>,
* <code>SpringLayout.WIDTH</code> or
* <code>SpringLayout.HEIGHT</code>.
* For any other <code>String</code> value passed as the edge,
* <code>null</code> will be returned. Throws
* <code>NullPointerException</code> for a <code>null</code> edge.
*
* @param edgeName the edge whose value
* is to be returned
*
* @return the spring controlling the specified edge, may be <code>null</code>
*
* @throws NullPointerException if <code>edgeName</code> is <code>null</code>
*
* @see #setConstraint
* @see #NORTH
* @see #SOUTH
* @see #EAST
* @see #WEST
* @see #HORIZONTAL_CENTER
* @see #VERTICAL_CENTER
* @see #BASELINE
* @see #WIDTH
* @see #HEIGHT
* @see SpringLayout.Constraints
*/
public Spring getConstraint(String edgeName) {
edgeName = edgeName.intern();
return (edgeName == WEST) ? getX() :
(edgeName == NORTH) ? getY() :
(edgeName == EAST) ? getEast() :
(edgeName == SOUTH) ? getSouth() :
(edgeName == WIDTH) ? getWidth() :
(edgeName == HEIGHT) ? getHeight() :
(edgeName == HORIZONTAL_CENTER) ? getHorizontalCenter() :
(edgeName == VERTICAL_CENTER) ? getVerticalCenter() :
(edgeName == BASELINE) ? getBaseline() :
null;
}
/*pp*/ void reset() {
Spring[] allSprings = {x, y, width, height, east, south,
horizontalCenter, verticalCenter, baseline};
for (Spring s : allSprings) {
if (s != null) {
s.setValue(Spring.UNSET);
}
}
}
}
private static class SpringProxy extends Spring {
private String edgeName;
private Component c;
private SpringLayout l;
public SpringProxy(String edgeName, Component c, SpringLayout l) {
this.edgeName = edgeName;
this.c = c;
this.l = l;
}
private Spring getConstraint() {
return l.getConstraints(c).getConstraint(edgeName);
}
public int getMinimumValue() {
return getConstraint().getMinimumValue();
}
public int getPreferredValue() {
return getConstraint().getPreferredValue();
}
public int getMaximumValue() {
return getConstraint().getMaximumValue();
}
public int getValue() {
return getConstraint().getValue();
}
public void setValue(int size) {
getConstraint().setValue(size);
}
/*pp*/ boolean isCyclic(SpringLayout l) {
return l.isCyclic(getConstraint());
}
public String toString() {
return "SpringProxy for " + edgeName + " edge of " + c.getName() + ".";
}
}
/**
* Constructs a new <code>SpringLayout</code>.
*/
public SpringLayout() {}
private void resetCyclicStatuses() {
cyclicSprings = new HashSet<Spring>();
acyclicSprings = new HashSet<Spring>();
}
private void setParent(Container p) {
resetCyclicStatuses();
Constraints pc = getConstraints(p);
pc.setX(Spring.constant(0));
pc.setY(Spring.constant(0));
// The applyDefaults() method automatically adds width and
// height springs that delegate their calculations to the
// getMinimumSize(), getPreferredSize() and getMaximumSize()
// methods of the relevant component. In the case of the
// parent this will cause an infinite loop since these
// methods, in turn, delegate their calculations to the
// layout manager. Check for this case and replace the
// the springs that would cause this problem with a
// constant springs that supply default values.
Spring width = pc.getWidth();
if (width instanceof Spring.WidthSpring && ((Spring.WidthSpring)width).c == p) {
pc.setWidth(Spring.constant(0, 0, Integer.MAX_VALUE));
}
Spring height = pc.getHeight();
if (height instanceof Spring.HeightSpring && ((Spring.HeightSpring)height).c == p) {
pc.setHeight(Spring.constant(0, 0, Integer.MAX_VALUE));
}
}
/*pp*/ boolean isCyclic(Spring s) {
if (s == null) {
return false;
}
if (cyclicSprings.contains(s)) {
return true;
}
if (acyclicSprings.contains(s)) {
return false;
}
cyclicSprings.add(s);
boolean result = s.isCyclic(this);
if (!result) {
acyclicSprings.add(s);
cyclicSprings.remove(s);
}
else {
System.err.println(s + " is cyclic. ");
}
return result;
}
private Spring abandonCycles(Spring s) {
return isCyclic(s) ? cyclicReference : s;
}
// LayoutManager methods.
/**
* Has no effect,
* since this layout manager does not
* use a per-component string.
*/
public void addLayoutComponent(String name, Component c) {}
/**
* Removes the constraints associated with the specified component.
*
* @param c the component being removed from the container
*/
public void removeLayoutComponent(Component c) {
componentConstraints.remove(c);
}
private static Dimension addInsets(int width, int height, Container p) {
Insets i = p.getInsets();
return new Dimension(width + i.left + i.right, height + i.top + i.bottom);
}
public Dimension minimumLayoutSize(Container parent) {
setParent(parent);
Constraints pc = getConstraints(parent);
return addInsets(abandonCycles(pc.getWidth()).getMinimumValue(),
abandonCycles(pc.getHeight()).getMinimumValue(),
parent);
}
public Dimension preferredLayoutSize(Container parent) {
setParent(parent);
Constraints pc = getConstraints(parent);
return addInsets(abandonCycles(pc.getWidth()).getPreferredValue(),
abandonCycles(pc.getHeight()).getPreferredValue(),
parent);
}
// LayoutManager2 methods.
public Dimension maximumLayoutSize(Container parent) {
setParent(parent);
Constraints pc = getConstraints(parent);
return addInsets(abandonCycles(pc.getWidth()).getMaximumValue(),
abandonCycles(pc.getHeight()).getMaximumValue(),
parent);
}
/**
* If <code>constraints</code> is an instance of
* <code>SpringLayout.Constraints</code>,
* associates the constraints with the specified component.
*
* @param component the component being added
* @param constraints the component's constraints
*
* @see SpringLayout.Constraints
*/
public void addLayoutComponent(Component component, Object constraints) {
if (constraints instanceof Constraints) {
putConstraints(component, (Constraints)constraints);
}
}
/**
* Returns 0.5f (centered).
*/
public float getLayoutAlignmentX(Container p) {
return 0.5f;
}
/**
* Returns 0.5f (centered).
*/
public float getLayoutAlignmentY(Container p) {
return 0.5f;
}
public void invalidateLayout(Container p) {}
// End of LayoutManger2 methods
/**
* Links edge <code>e1</code> of component <code>c1</code> to
* edge <code>e2</code> of component <code>c2</code>,
* with a fixed distance between the edges. This
* constraint will cause the assignment
* <pre>
* value(e1, c1) = value(e2, c2) + pad</pre>
* to take place during all subsequent layout operations.
*
* @param e1 the edge of the dependent
* @param c1 the component of the dependent
* @param pad the fixed distance between dependent and anchor
* @param e2 the edge of the anchor
* @param c2 the component of the anchor
*
* @see #putConstraint(String, Component, Spring, String, Component)
*/
public void putConstraint(String e1, Component c1, int pad, String e2, Component c2) {
putConstraint(e1, c1, Spring.constant(pad), e2, c2);
}
/**
* Links edge <code>e1</code> of component <code>c1</code> to
* edge <code>e2</code> of component <code>c2</code>. As edge
* <code>(e2, c2)</code> changes value, edge <code>(e1, c1)</code> will
* be calculated by taking the (spring) sum of <code>(e2, c2)</code>
* and <code>s</code>.
* Each edge must have one of the following values:
* <code>SpringLayout.NORTH</code>,
* <code>SpringLayout.SOUTH</code>,
* <code>SpringLayout.EAST</code>,
* <code>SpringLayout.WEST</code>,
* <code>SpringLayout.VERTICAL_CENTER</code>,
* <code>SpringLayout.HORIZONTAL_CENTER</code> or
* <code>SpringLayout.BASELINE</code>.
*
* @param e1 the edge of the dependent
* @param c1 the component of the dependent
* @param s the spring linking dependent and anchor
* @param e2 the edge of the anchor
* @param c2 the component of the anchor
*
* @see #putConstraint(String, Component, int, String, Component)
* @see #NORTH
* @see #SOUTH
* @see #EAST
* @see #WEST
* @see #VERTICAL_CENTER
* @see #HORIZONTAL_CENTER
* @see #BASELINE
*/
public void putConstraint(String e1, Component c1, Spring s, String e2, Component c2) {
putConstraint(e1, c1, Spring.sum(s, getConstraint(e2, c2)));
}
private void putConstraint(String e, Component c, Spring s) {
if (s != null) {
getConstraints(c).setConstraint(e, s);
}
}
private Constraints applyDefaults(Component c, Constraints constraints) {
if (constraints == null) {
constraints = new Constraints();
}
if (constraints.c == null) {
constraints.c = c;
}
if (constraints.horizontalHistory.size() < 2) {
applyDefaults(constraints, WEST, Spring.constant(0), WIDTH,
Spring.width(c), constraints.horizontalHistory);
}
if (constraints.verticalHistory.size() < 2) {
applyDefaults(constraints, NORTH, Spring.constant(0), HEIGHT,
Spring.height(c), constraints.verticalHistory);
}
return constraints;
}
private void applyDefaults(Constraints constraints, String name1,
Spring spring1, String name2, Spring spring2,
List<String> history) {
if (history.size() == 0) {
constraints.setConstraint(name1, spring1);
constraints.setConstraint(name2, spring2);
} else {
// At this point there must be exactly one constraint defined already.
// Check width/height first.
if (constraints.getConstraint(name2) == null) {
constraints.setConstraint(name2, spring2);
} else {
// If width/height is already defined, install a default for x/y.
constraints.setConstraint(name1, spring1);
}
// Either way, leave the user's constraint topmost on the stack.
Collections.rotate(history, 1);
}
}
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java