Comment disposer plusieurs panneaux sur un jFrame? (Java)

Question

Je suis en train de créer mon propre jeu de socket Java. Mon jeu peint bien en plein écran (où il est écrit "Paint graphics here", mais je peins sur l'ensemble du jframe au Je veux ajouter une zone de texte avec une barre de défilement pour afficher niquement texte, ne prenant aucune entrée et une autre zone de texte pour prendre les entrées de texte de l'utilisateur, puis un bouton pour envoyer le texte, pour le chat Mais sur ma question, comment puis-je même commencer à mettre cela en place? Je comprends que j'ai besoin d'une mise en page, mais quelqu'un peut-il m'aider à ce sujet? Voici mon code pour le moment (ce code ne configure la peinture que sur tout l'écran) pour le moment, besoin de diviser l'écran maintenant comme je l'ai dans l'image ci-dessus):

public class Setup extends JFrame implements Runnable{
     JPanel panel;
     JFrame window;
     public Setup(Starter start, JFrame window){
         window.setSize(600,500);
         window.setLocationRelativeTo(null);
         window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         window.setResizable(false);
         panel = new Display(start);
         this.window = window;
     }
     public void run(){
         window.getContentPane().add(panel);
         window.setBackground(Color.BLACK);
         window.setVisible(true);
     }
}

"nouvel affichage (début)" - cela étend jpanel, c'est essentiellement là où je peins tout ce qui est graphique.

De plus, j'ai vu des gens ajouter des panneaux différents, mais je ne peux pas les faire avoir la même taille. Comme dans l'image, le panneau "Paint graphics here" est le plus grand, et ainsi de suite.

Answer 1

Le JPanel n'est en fait qu'un conteneur où vous pouvez y mettre différents éléments (même d'autres JPanels). Donc, dans votre cas, je suggère un gros JPanel comme une sorte de conteneur principal pour votre fenêtre. Que panneau principal vous attribuez un Layout qui convient à vos besoins ( voici une introduction aux dispositions ).

Après avoir défini la mise en page de votre panneau principal vous pouvez ajouter le panneau de peinture et les autres JPanels que vous souhaitez (comme ceux qui contiennent du texte ..) .

  JPanel mainPanel = new JPanel();
  mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));

  JPanel paintPanel = new JPanel();
  JPanel textPanel = new JPanel();

  mainPanel.add(paintPanel);
  mainPanel.add(textPanel);

Ceci est juste un exemple qui trie tous les sous-panneaux verticalement (axe Y). Donc, si vous voulez d'autres éléments au bas de votre panneau principal (peut-être des icônes ou des boutons) qui devraient être organisés avec une autre disposition (comme une disposition horizontale), créez simplement à nouveau un nouveau JPanel comme un conteneur pour toutes les autres choses et définissez setLayout(new BoxLayout(mainPanel, BoxLayout.X_AXIS).

Comme vous le découvrirez, les dispositions sont assez rigides et il peut être difficile de trouver la meilleure disposition pour vos panneaux. Alors n'abandonnez pas, lisez l'introduction (le lien ci-dessus) et regardez les photos - c'est comme ça que je le fais :)

Ou vous pouvez simplement utiliser NetBeans pour écrire votre programme. Là, vous avez un éditeur visuel assez simple (glisser-déposer) pour créer toutes sortes de fenêtres et de cadres. (seulement comprendre le code par la suite est ... parfois délicat.)

MODIFIER

Puisqu'il y a beaucoup de gens intéressés par cette question, je voulais fournir un exemple complet de la façon de mettre en page un JFrame pour le faire ressembler à OP le souhaite.

La classe est appelée MyFrame et étend les balançoires JFrame

public class MyFrame extends javax.swing.JFrame{

    // these are the components we need.
    private final JSplitPane splitPane;  // split the window in top and bottom
    private final JPanel topPanel;       // container panel for the top
    private final JPanel bottomPanel;    // container panel for the bottom
    private final JScrollPane scrollPane; // makes the text scrollable
    private final JTextArea textArea;     // the text
    private final JPanel inputPanel;      // under the text a container for all the input elements
    private final JTextField textField;   // a textField for the text the user inputs
    private final JButton button;         // and a "send" button

    public MyFrame(){

        // first, lets create the containers:
        // the splitPane devides the window in two components (here: top and bottom)
        // users can then move the devider and decide how much of the top component
        // and how much of the bottom component they want to see.
        splitPane = new JSplitPane();

        topPanel = new JPanel();         // our top component
        bottomPanel = new JPanel();      // our bottom component

        // in our bottom panel we want the text area and the input components
        scrollPane = new JScrollPane();  // this scrollPane is used to make the text area scrollable
        textArea = new JTextArea();      // this text area will be put inside the scrollPane

        // the input components will be put in a separate panel
        inputPanel = new JPanel();
        textField = new JTextField();    // first the input field where the user can type his text
        button = new JButton("send");    // and a button at the right, to send the text

        // now lets define the default size of our window and its layout:
        setPreferredSize(new Dimension(400, 400));     // let's open the window with a default size of 400x400 pixels
        // the contentPane is the container that holds all our components
        getContentPane().setLayout(new GridLayout());  // the default GridLayout is like a grid with 1 column and 1 row,
        // we only add one element to the window itself
        getContentPane().add(splitPane);               // due to the GridLayout, our splitPane will now fill the whole window

        // let's configure our splitPane:
        splitPane.setOrientation(JSplitPane.VERTICAL_SPLIT);  // we want it to split the window verticaly
        splitPane.setDividerLocation(200);                    // the initial position of the divider is 200 (our window is 400 pixels high)
        splitPane.setTopComponent(topPanel);                  // at the top we want our "topPanel"
        splitPane.setBottomComponent(bottomPanel);            // and at the bottom we want our "bottomPanel"

        // our topPanel doesn't need anymore for this example. Whatever you want it to contain, you can add it here
        bottomPanel.setLayout(new BoxLayout(bottomPanel, BoxLayout.Y_AXIS)); // BoxLayout.Y_AXIS will arrange the content vertically

        bottomPanel.add(scrollPane);                // first we add the scrollPane to the bottomPanel, so it is at the top
        scrollPane.setViewportView(textArea);       // the scrollPane should make the textArea scrollable, so we define the viewport
        bottomPanel.add(inputPanel);                // then we add the inputPanel to the bottomPanel, so it under the scrollPane / textArea

        // let's set the maximum size of the inputPanel, so it doesn't get too big when the user resizes the window
        inputPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, 75));     // we set the max height to 75 and the max width to (almost) unlimited
        inputPanel.setLayout(new BoxLayout(inputPanel, BoxLayout.X_AXIS));   // X_Axis will arrange the content horizontally

        inputPanel.add(textField);        // left will be the textField
        inputPanel.add(button);           // and right the "send" button

        pack();   // calling pack() at the end, will ensure that every layout and size we just defined gets applied before the stuff becomes visible
    }

    public static void main(String args[]){
        EventQueue.invokeLater(new Runnable(){
            @Override
            public void run(){
                new MyFrame().setVisible(true);
            }
        });
    }
}

Veuillez noter qu'il ne s'agit que d'un exemple et qu'il existe plusieurs approches pour mettre en page une fenêtre. Tout dépend de vos besoins et si vous souhaitez que le contenu soit redimensionnable/réactif. Une autre très bonne approche serait le GridBagLayout qui peut gérer une mise en page assez complexe, mais qui est également assez complexe à apprendre.

Answer 2

Vous souhaiterez utiliser un certain nombre de gestionnaires de mise en page pour vous aider à obtenir les résultats de base que vous souhaitez.

Consultez n guide visuel pour les gestionnaires de mise en page pour une comparaison.

Vous pouvez utiliser un GridBagLayout mais c'est l'un des gestionnaires de mise en page les plus complexes (et les plus puissants) disponibles dans le JDK.

Vous pouvez utiliser à la place une série de gestionnaires de disposition composés.

Je placerais le composant graphique et la zone de texte sur un seul JPanel, en utilisant un BorderLayout, avec le composant graphique dans le CENTER et la zone de texte dans le SOUTH.

Je placerais le champ de texte et le bouton sur un JPanel séparé en utilisant un GridBagLayout (car c'est le plus simple auquel je puisse penser pour obtenir le résultat souhaité)

Je placerais ces deux panneaux sur un troisième, maître, panneau, en utilisant un BorderLayout, avec le premier panneau en CENTER et le second en position SOUTH.

Mais c'est moi