Name: rk38400 Date: 05/20/98


Box layout sizes incorrectly:

Here is some example code:

import com.sun.java.swing.*;
import java.awt.*;

public class bug extends JFrame {
    public bug() {
        super("bug");

        Container cp = this.getContentPane();
        cp.setLayout(new BoxLayout(cp, BoxLayout.Y_AXIS));

        JPanel eq = new JPanel();
        eq.setLayout(new BoxLayout(eq, BoxLayout.X_AXIS));
        eq.add(new JButton("Middle One"));
        eq.add(new JButton("Mid two"));

        JButton b;
        cp.add(b = new JButton("Centered Button Long"));
        b.setAlignmentX(Component.CENTER_ALIGNMENT);
        cp.add(eq);
        cp.add(b = new JButton("Left Button"));
        b.setAlignmentX(Component.LEFT_ALIGNMENT);
        cp.add(b = new JButton("Right Button"));
        b.setAlignmentX(Component.RIGHT_ALIGNMENT);

        pack();
        show();
    }

    static public void main(String args[]) { new bug(); }
}

as you see when you run it, the size is too wide for the given componets
and their alignments are not correct.

The problem appears to be in SizeRequirements.

The following changed methods seem to fix it:

    public static void calculateAlignedPositions(int allocated,
                                                 SizeRequirements total,
                                                 SizeRequirements[] children,
                                                 int[] offsets,
                                                 int[] spans) {
        for (int i = 0; i < children.length; i++) {
            SizeRequirements req = children[i];
            int span = 0;
            if (allocated > req.preferred) {
                span = Math.min(allocated, req.maximum);
            } else {
                span = Math.max(allocated, req.minimum);
            }

            offsets[i] = (int)((allocated - span)*req.alignment);
            spans[i] = span;
        }
}

    public static SizeRequirements getAlignedSizeRequirements(SizeRequirements
[]
                                                              children) {
int min = 0;
int pref = 0;
int max = 0;
float maxminAscent = 0.0f;
for (int i = 0; i < children.length; i++) {
  SizeRequirements req = children[i];
  int ascent = (int) (req.alignment * req.minimum);
  int descent = req.minimum - ascent;
  min = Math.min(Math.max(ascent+descent, min), Integer.MAX_VALUE);
  maxminAscent = Math.max(ascent, maxminAscent);

  ascent = (int) (req.alignment * req.preferred);
  descent = req.preferred - ascent;
  pref = Math.min(Math.max(ascent+descent, pref), Integer.MAX_VALUE);

  ascent = (int) (req.alignment * req.maximum);
  descent = req.maximum - ascent;
  max = Math.min(Math.max(ascent+descent, max), Integer.MAX_VALUE);
}
float alignment = 0.0f;
if (min > 0) {
    alignment = (float) maxminAscent/ min;
    alignment = alignment > 1.0f ? 1.0f : alignment < 0.0f ? 0.0f : alignment;
}
return new SizeRequirements(min, pref, max, alignment);
}
(Review ID: 29554)
======================================================================
###@###.### 10/12/04 18:24 GMT