evento - tamaño de un panel java

¿Cómo funciona realmente el tamaño de un JFrame?

Question

No tengo ningún propósito para lo que realmente estoy haciendo, solo estoy probando cosas con Java Swing. Lo que tengo ahora son estas tres variables:

    int[] gridIterations = {10,10}; //how many JButtons are made each row/column
    int[] frameSize = {600,600}; //size of the JFrame
    int[] gridSize = {60,60}; //by gridSize, I mean size of the JButtons

También tengo un ciclo anidado que usa estas variables para crear una grilla de JButtons. Esperaría que las cuadrículas se ajustaran perfectamente al JFrame, sin embargo, este es el resultado:

Después de algunas pruebas, me di cuenta de que el marco solo se ajustaría a todos los JButton si el tamaño es (615, 631) Pero me pregunto, ¿por qué encaja solo con estos parámetros y por qué, de todos los números, serían esos? ? A mi entender, un cálculo simple de 60 * 10 debería equivaler a 600 y tener con éxito todos los botones que caben en el JFrame, pero lo más probable es que pase por alto algo. ¿Qué podría ser eso? Gracias.

Answer 1

El tamaño de un JFrame incluye sus insertos. Esto básicamente significa la barra de título y los bordes.

GridLayout hará esto perfectamente para usted con mucho menos esfuerzo.

class GridButtons implements Runnable {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(new GridButtons(4, 5));
    }

    final int rows;
    final int cols;

    GridButtons(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
    }

    @Override
    public void run() {
        JFrame frame = new JFrame();
        JPanel grid = new JPanel(new GridLayout(rows, cols));

        for (int i = 0; i < (rows * cols); ++i) {
            grid.add(new JButton() {
                @Override
                public Dimension getPreferredSize() {
                    return new Dimension(60, 60);
                }
            });
        }

        frame.setContentPane(grid);
        frame.pack();
        frame.setResizable(false);
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Answer 2

Mucho se reduce a los requisitos del contenido y el administrador de diseño. En lugar de mirar "qué tan grande" le gustaría que sea el marco, concéntrese en la cantidad de espacio que necesita el contenido. El marco se "empacará" alrededor de esto.

Esto significa que el cuadro tendrá "tamaño de contenido + tamaño de borde de marco" grande.

JFrame#pack toma en consideración el tamaño preferido del contenido y agrega los encuadres de borde de marcos automáticamente.

Entonces, lo único que necesita es llamar a JFrame#pack DESPUÉS de que termine de agregarle el contenido

Entonces, basado en tu código:

public class Testing {

        public static void main(String[] args) {
                JFrame frame = new JFrame("hi");

                for (int i = 0; i < 10; i++) {
                        JButton a = new JButton();
                        a.setSize(20,20);
                        a.setLocation(20*i, 0);
                        frame.getContentPane().add(a);

                }
                frame.setLayout(null);
                frame.pack();
                frame.setVisible(true);
        }

}

Estás usando un diseño null . JFrame#pack utilizará la información proporcionada por el administrador de diseño para determinar el tamaño "preferido" del contenido general.

Evite el uso de diseños null , los diseños perfectos de píxeles son una ilusión dentro del diseño moderno de la interfaz de usuario. Hay demasiados factores que afectan el tamaño individual de los componentes, ninguno de los cuales puede controlar. Swing fue diseñado para trabajar con los administradores de diseño en el núcleo, descartar estos llevará a un sinfín de problemas y problemas que pasará más y más tiempo tratando de rectificar.

Más bien, el enfoque en lo absoluto, que sería variable entre los sistemas operativos (e incluso diferentes PC con el mismo sistema operativo), se centra en la experiencia del usuario.

Como ya se ha demostrado, puede hacer que esto funcione fácilmente usando un GridLayout

import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

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

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        public TestPane() {
            setLayout(new GridLayout(10, 10, 0, 0));
            for (int index = 0; index < 10 * 10; index++) {
                JButton btn = new JButton(String.valueOf(index)) {
                    @Override
                    public Dimension getPreferredSize() {
                        return new Dimension(50, 50);
                    }
                };
                add(btn);
            }
        }

    }

}

Si necesita una administración más compleja (es decir, profundidad por amplitud), podría usar un GridBagLayout en GridBagLayout lugar

Eche un vistazo a Laying Out Components within a Container , Cómo usar GridLayout y Cómo usar GridBagLayout para más detalles;)