public abstract class Spring extends Object
Spring
class holds three properties that characterize its behavior: the minimum, preferred, and maximum values. Each of these properties may be involved in defining its fourth, value, property based on a series of rules. An instance of the Spring
class can be visualized as a mechanical spring that provides a corrective force as the spring is compressed or stretched away from its preferred value. This force is modelled as linear function of the distance from the preferred value, but with two different constants -- one for the compressional force and one for the tensional one. Those constants are specified by the minimum and maximum values of the spring such that a spring at its minimum value produces an equal and opposite force to that which is created when it is at its maximum value. The difference between the preferred and minimum values, therefore, represents the ease with which the spring can be compressed and the difference between its maximum and preferred values, indicates the ease with which the Spring
can be extended. See the sum(javax.swing.Spring, javax.swing.Spring)
method for details.
By defining simple arithmetic operations on Spring
s, the behavior of a collection of Spring
s can be reduced to that of an ordinary (non-compound) Spring
. We define the "+", "-", max, and min operators on Spring
s so that, in each case, the result is a Spring
whose characteristics bear a useful mathematical relationship to its constituent springs.
A Spring
can be treated as a pair of intervals with a single common point: the preferred value. The following rules define some of the arithmetic operators that can be applied to intervals ([a, b]
refers to the interval from a
to b
, where a <= b
).
[a1, b1] + [a2, b2] = [a1 + a2, b1 + b2] -[a, b] = [-b, -a] max([a1, b1], [a2, b2]) = [max(a1, a2), max(b1, b2)]
If we denote Spring
s as [a, b, c]
, where a <= b <= c
, we can define the same arithmetic operators on Spring
s:
[a1, b1, c1] + [a2, b2, c2] = [a1 + a2, b1 + b2, c1 + c2] -[a, b, c] = [-c, -b, -a] max([a1, b1, c1], [a2, b2, c2]) = [max(a1, a2), max(b1, b2), max(c1, c2)]
With both intervals and Spring
s we can define "-" and min in terms of negation:
X - Y = X + (-Y) min(X, Y) = -max(-X, -Y)
For the static methods in this class that embody the arithmetic operators, we do not actually perform the operation in question as that would snapshot the values of the properties of the method's arguments at the time the static method is called. Instead, the static methods create a new Spring
instance containing references to the method's arguments so that the characteristics of the new spring track the potentially changing characteristics of the springs from which it was made. This is a little like the idea of a lazy value in a functional language.
If you are implementing a SpringLayout
you can find further information and examples in How to Use SpringLayout, a section in The Java Tutorial.
Warning: 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 java.beans
package. Please see XMLEncoder
.
Modifier and Type | Field | Description |
---|---|---|
static final int |
UNSET |
An integer value signifying that a property value has not yet been calculated. |
Modifier | Constructor | Description |
---|---|---|
protected |
Used by factory methods to create a Spring . |
Modifier and Type | Method | Description |
---|---|---|
static Spring |
constant |
Returns a strut -- a spring whose minimum, preferred, and maximum values each have the value pref . |
static Spring |
constant |
Returns a spring whose minimum, preferred, and maximum values have the values: min , pref , and max respectively. |
abstract int |
getMaximumValue() |
Returns the maximum value of this Spring . |
abstract int |
getMinimumValue() |
Returns the minimum value of this Spring . |
abstract int |
getPreferredValue() |
Returns the preferred value of this Spring . |
abstract int |
getValue() |
Returns the current value of this Spring . |
static Spring |
height |
Returns a spring whose minimum, preferred, maximum and value properties are defined by the heights of the minimumSize, preferredSize, maximumSize and size properties of the supplied component. |
static Spring |
max |
Returns max(s1, s2) : a spring whose value is always greater than (or equal to) the values of both s1 and s2 . |
static Spring |
minus |
Returns -s : a spring running in the opposite direction to s . |
static Spring |
scale |
Returns a spring whose minimum, preferred, maximum and value properties are each multiples of the properties of the argument spring, s . |
abstract void |
setValue |
Sets the current value of this Spring to value . |
static Spring |
sum |
Returns s1+s2 : a spring representing s1 and s2 in series. |
static Spring |
width |
Returns a spring whose minimum, preferred, maximum and value properties are defined by the widths of the minimumSize, preferredSize, maximumSize and size properties of the supplied component. |
public static final int UNSET
protected Spring()
Spring
.public abstract int getMinimumValue()
Spring
.minimumValue
property of this Spring
public abstract int getPreferredValue()
Spring
.preferredValue
of this Spring
public abstract int getMaximumValue()
Spring
.maximumValue
property of this Spring
public abstract int getValue()
Spring
.value
property of this Spring
public abstract void setValue(int value)
Spring
to value
.value
- the new setting of the value
propertypublic static Spring constant(int pref)
pref
.pref
- the minimum, preferred, and maximum values of the new springpref
public static Spring constant(int min, int pref, int max)
min
, pref
, and max
respectively.min
- the minimum value of the new springpref
- the preferred value of the new springmax
- the maximum value of the new springmin
, pref
, and max
respectivelypublic static Spring minus(Spring s)
-s
: a spring running in the opposite direction to s
.s
- a Spring
object-s
: a spring running in the opposite direction to s
public static Spring sum(Spring s1, Spring s2)
s1+s2
: a spring representing s1
and s2
in series. In a sum, s3
, of two springs, s1
and s2
, the strains of s1
, s2
, and s3
are maintained at the same level (to within the precision implied by their integer values). The strain of a spring in compression is: value - pref ------------ pref - minand the strain of a spring in tension is:
value - pref ------------ max - prefWhen
setValue
is called on the sum spring, s3
, the strain in s3
is calculated using one of the formulas above. Once the strain of the sum is known, the values of s1
and s2
are then set so that they are have a strain equal to that of the sum. The formulas are evaluated so as to take rounding errors into account and ensure that the sum of the values of s1
and s2
is exactly equal to the value of s3
.s1
- a Spring
objects2
- a Spring
objects1+s2
: a spring representing s1
and s2
in seriespublic static Spring max(Spring s1, Spring s2)
max(s1, s2)
: a spring whose value is always greater than (or equal to) the values of both s1
and s2
.s1
- a Spring
objects2
- a Spring
objectmax(s1, s2)
: a spring whose value is always greater than (or equal to) the values of both s1
and s2
public static Spring scale(Spring s, float factor)
s
. Minimum and maximum properties are swapped when factor
is negative (in accordance with the rules of interval arithmetic). When factor is, for example, 0.5f the result represents 'the mid-point' of its input - an operation that is useful for centering components in a container.
s
- the spring to scalefactor
- amount to scale by.s
multiplied by factor
NullPointerException
- if s
is nullpublic static Spring width(Component c)
c
- Component used for calculating sizeNullPointerException
- if c
is nullpublic static Spring height(Component c)
c
- Component used for calculating sizeNullPointerException
- if c
is null
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.desktop/javax/swing/Spring.html