添加组件时ScrollPane扩展

Question

I've spent a while creating an sscce from my larger program, I hope it's small enough!

I've a JSplitPane with a table on top, and below is a JPanel.

The bottom panel contains smaller JPanels, or 'entries'. As the number of entries grows, the bottom SplitPane takes up the space of the top pane.

Dimension dim = getPreferredSize();        
setPreferredSize(dim);

In the first class, uncommenting this code solves the problem, but I've no idea why. I'd like to understand how to deal with resizing better if anyone can help? (I've also got to deal with the text area expanding horizontally, which is one of the reasons some of the constraints might look a little odd)

Here's the bottom panel:

package example;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import javax.swing.*;
import javax.swing.border.Border;

public class BottomPanel extends JPanel{
    private JLabel summary = new JLabel();
    private EntryPanel entryPanel = new EntryPanel(); 

    public BottomPanel() {
        //Dimension dim = getPreferredSize();
        //setPreferredSize(dim);
        setLayout(new GridBagLayout());
        entryPanel.setBorder(BorderFactory.createLineBorder(Color.RED));
        setComponents();
    }

    private void setComponents() {
        Border test = BorderFactory.createLineBorder(Color.BLUE);
        JScrollPane jsp = new JScrollPane(entryPanel);
        JPanel dummy1 = new JPanel();
        JPanel dummy2 = new JPanel();
        JPanel dummy3 = new JPanel();
        dummy1.setBorder(test);
        dummy2.setBorder(test);
        dummy3.setBorder(test);

        int row = 0;
        add(dummy1, new GBC(0,row).setWeight(0,0));
        // new row
        row++;
        add(summary, new GBC(1,row).setAnchor(GBC.LINE_START));   
        // new row
        row++;
        add(jsp, new GBC(1,row).setWeight(50,70).setFill(GBC.BOTH));
        // new row
        row++;
        add(dummy2, new GBC(2,row).setWeight(0,0));
    }

    private class EntryPanel extends JPanel{
        private List<JPanel> entries = new ArrayList<>();
        private int row = 0;

        private EntryPanel(){
            setLayout(new GridBagLayout());
            for(int x = 0; x < 20; x++)
                createEntryItem("TEST", "test text");
        }

        private void createEntryItem(String s, String text){
            Border test = BorderFactory.createLineBorder(Color.GREEN);
            JPanel entryItem = new JPanel();
            entryItem.setBorder(test);
            entryItem.setLayout(new GridBagLayout());
            JLabel title = new JLabel(s);
            JTextArea details = new JTextArea(text);  

            entryItem.add(title, new GBC(0,0).setAnchor(GBC.LINE_START));
            entryItem.add(details, new GBC(0,1).setAnchor(GBC.LINE_START));
            entryItem.add(new JPanel(), new GBC(1,0).setWeight(100,0));
            entries.add(entryItem);
            displayEntry(entryItem);
        }

        private void displayEntry(JPanel entry){
            JPanel dummy = new JPanel();
            add(entry, new                         GBC(0,row).setAnchor(GBC.LINE_START).setFill(GBC.HORIZONTAL));
            add(dummy, new GBC(1,row).setWeight(100, 0));
            row++;
        }
    }
}

and the containing frame and panel:

package example;
import java.awt.*;
import javax.swing.*;

public class Example extends JFrame{
    private GraphicsDevice gd =     GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();     
    private int width = (int)((gd.getDisplayMode().getWidth())*0.5);
    private int height = (int)((gd.getDisplayMode().getHeight())*0.75);
    private JPanel mainPanel = new JPanel();
    private JSplitPane sp;
    private JTable table = new JTable();
    private BottomPanel bp = new BottomPanel();

    public Example () {
        setSize(width,height);
        setLayout(new BorderLayout());
        sp = new JSplitPane(JSplitPane.VERTICAL_SPLIT,new JScrollPane(table), bp);
        add(sp);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args){
        SwingUtilities.invokeLater(new Runnable(){
            public void run(){
                Example ex = new Example();
            }
        });
    } 
}

and the GridBagHelper:

package example;
import java.awt.GridBagConstraints;

public class GBC extends GridBagConstraints{  
   public GBC(int gridx, int gridy){
      this.gridx = gridx;
      this.gridy = gridy;
   }

   public GBC setAnchor(int anchor){
      this.anchor = anchor;
      return this;
   }

   public GBC setFill(int fill){
      this.fill = fill;
      return this;
   }

   public GBC setWeight(double weightx, double weighty){
      this.weightx = weightx;
      this.weighty = weighty;
      return this;
   }
}

Any help or advice would be really appreciated - I'm self taught and am struggling a fair bit!

Thanks

Answer 1

I'm too tired to write a proper answer, but I'm glancing through this and one of the first issues I see is setSize(width,height) inside the constructor for Example . It's better to call pack() on the JFrame and let it size everything itself automatically.

I think pack can be a bit unpredictable with a JScrollPane , though. From memory, I've had it do some weird things like collapse the scroll pane to its minimum size.

Using pack on your code example seems to attempt to size it around the sum of the panels in BottomPanel . (The sum would be taller than my screen resolution, though, so I can't tell what the exact behavior is. It caps the height of the window at the height of my screen.)

A more elegant way to do what you're trying to do is like this:

public Example () {
    // setSize(width,height);
    // setLayout(new BorderLayout());
    sp = new JSplitPane(JSplitPane.VERTICAL_SPLIT,new JScrollPane(table), bp);
    sp.setResizeWeight(2.0 / 3.0);
    sp.setPreferredSize(width, height);
    setContentPane(sp);
    // add(sp);
    pack();
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);
    setVisible(true);
}

I used setResizeWeight to achieve the split pane proportions and set the preferred size of the pane instead of the window.

This is pretty similar to the result that you like but it's a little more proper. It could be that one of the more experienced Swing users here knows a better way to use JScrollPane which eg doesn't involve an explicit setPreferredSize .

Answer 2

I guess my question is why getting the preferredSize, and then setting the preferredSize makes a difference?

If we dig down through the code, you'll find...

public void setPreferredSize(Dimension preferredSize) {
    Dimension old;
    // If the preferred size was set, use it as the old value, otherwise
    // use null to indicate we didn't previously have a set preferred
    // size.
    if (prefSizeSet) {
        old = this.prefSize;
    }
    else {
        old = null;
    }
    this.prefSize = preferredSize;
    prefSizeSet = (preferredSize != null);
    firePropertyChange("preferredSize", old, preferredSize);
}

You can the have a look at how getPreferredSize works...

public boolean isPreferredSizeSet() {
    return prefSizeSet;
}


/**
 * Gets the preferred size of this component.
 * @return a dimension object indicating this component's preferred size
 * @see #getMinimumSize
 * @see LayoutManager
 */
public Dimension getPreferredSize() {
    return preferredSize();
}


/**
 * @deprecated As of JDK version 1.1,
 * replaced by <code>getPreferredSize()</code>.
 */
@Deprecated
public Dimension preferredSize() {
    /* Avoid grabbing the lock if a reasonable cached size value
     * is available.
     */
    Dimension dim = prefSize;
    if (dim == null || !(isPreferredSizeSet() || isValid())) {
        synchronized (getTreeLock()) {
            prefSize = (peer != null) ?
                peer.getPreferredSize() :
                getMinimumSize();
            dim = prefSize;
        }
    }
    return new Dimension(dim);
}

This will return the user set preferredSize if it was set, over calculating its own.

surely i'm assigning a value that was already in place?

But you call setPreferredSize before any components are added to the container

If you change the code to something like...

Dimension dim = getPreferredSize();
System.out.println(dim);
setPreferredSize(dim);

it will print out something like java.awt.Dimension[width=10,height=10] , so, yeah, small...

But, if you use something like...

public BottomPanel() {
    setLayout(new GridBagLayout());
    entryPanel.setBorder(BorderFactory.createLineBorder(Color.RED));
    setComponents();
    Dimension dim = getPreferredSize();
    System.out.println(dim);
    setPreferredSize(dim);
}

it prints out java.awt.Dimension[width=105,height=710]

The basic moral to the story is, don't call setPreferred/Minimum/MaximumSize unless you have a very, very good reason to and even then, consider overriding getPreferredSize instead. It's no one else's responsibility to calculate the size of the component, but the componet itself