Name: jk109818 Date: 11/14/2002


FULL PRODUCT VERSION :
java version "1.4.1"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.1-b21)
Java HotSpot(TM) Client VM (build 1.4.1-b21, mixed mode)

FULL OPERATING SYSTEM VERSION :
Microsoft Windows 2000 [Version 5.00.2195]



A DESCRIPTION OF THE PROBLEM :
Springs produced by Spring.max behave unexpectedly in
response to setValue(x) call. The expected behavior is that
MaxSpring.setValue(x) calls setValue(x) for both of its
operands. Instead, it calls setValue(x) for the operand
with larger preferredSize and setValue(min(x,preferredSize)
for the operand with smaller preferredSize.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
Compile & run the source code included with this report.


EXPECTED VERSUS ACTUAL BEHAVIOR :
Expected result:
Frame window contains two buttons of equal height (200
pixels). Height of both buttons should track the window
height.

Actual result:
Frame window contains two buttons of different size - Left
button is 200 pixels, right button is 100 pixels. Height of
the right button does not track the window height.

REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
import java.awt.Container;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JComponent;

import javax.swing.SpringLayout;
import javax.swing.Spring;

public class SpringTest0 extends JFrame {
     
    public SpringTest0() {
initComponents(getContentPane());
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
    
    private void initComponents(Container parent) {
        
        final SpringLayout layout = new SpringLayout();
        parent.setLayout(layout);

        final Dimension[][] dims = new Dimension[][] {
            { // 0
              new Dimension( 100, 100), // minimum size
              new Dimension( 100, 200), // preferred size
              new Dimension(1100,1200) }, // maximum size
            { // 1
              new Dimension( 100, 0), // minimum size
              new Dimension( 150, 100), // preferred size
              new Dimension( 150,1100) }, // maximum size
        };
        
        final Spring[] compWidth
            = new Spring[dims.length];
        final Spring[] compHeight
            = new Spring[dims.length];
        final SpringLayout.Constraints[] compCons
            = new SpringLayout.Constraints[dims.length];
        
        for (int i = 0; i < dims.length; ++i) {
            final JComponent comp = new JButton("Component " + i);
            comp.setMinimumSize(dims[i][0]);
            comp.setPreferredSize(dims[i][1]);
            comp.setMaximumSize(dims[i][2]);
            parent.add(comp);
            compCons[i] = layout.getConstraints(comp);
            compWidth[i] = compCons[i].getWidth();
            compHeight[i] = compCons[i].getHeight();
        }

        final Spring padx = Spring.constant(5);
        final Spring pady = Spring.constant(5);

        final Spring width
            = Spring.sum(padx, Spring.sum(compWidth[0], compWidth[1]));
        final Spring height
            = Spring.max(compHeight[0], compHeight[1]);
        
        compCons[0].setX(
            padx);
        compCons[0].setY(
            pady);

        compCons[1].setX(
            Spring.sum(padx, compCons[0].getConstraint(SpringLayout.EAST)));
        compCons[1].setY(
            pady);
        
        final SpringLayout.Constraints consP = layout.getConstraints(parent);
        
        consP.setConstraint(SpringLayout.EAST,
            Spring.sum(padx, Spring.sum(padx, width)));
        consP.setConstraint(SpringLayout.SOUTH,
            Spring.sum(pady, Spring.sum(pady, height)));
    }
    
    public static void main(String args[]) {
        SpringTest0 window = new SpringTest0();
        window.setTitle("SpringLayout");
        window.pack();
        window.setVisible(true);
    }
}

---------- END SOURCE ----------

CUSTOMER WORKAROUND :
create an alternative implementation of Spring.MaxSpring
class using the following code for setValue method:

        public void setValue(int size) {
            super.setValue(size);
            if (size == UNSET) {
                return;
            }
            // Pending should also check max bounds here.
            if (s1.getPreferredValue() <
s2.getPreferredValue()) {
                s1.setValue(Math.min(size,
s1.getMaximumValue()));
                s2.setValue(size);
            }
            else {
                s1.setValue(size);
                s2.setValue(Math.min(size,
s2.getMaximumValue()));
            }
        }
(Review ID: 166981)
======================================================================
###@###.### 10/4/04 20:08 GMT