webentwicklung-frage-antwort-db.com.de

Wie werden mehrere Panels auf einem jFrame angeordnet? (Java)

Layout wanted

Ich bin gerade dabei, mein eigenes Java Socket-Spiel zu erstellen. Mein Spiel malt in Ordnung auf dem ganzen Bildschirm (dort steht "Malen Sie hier Grafiken"), aber ich male auf dem ganzen jframe Ich möchte ein Textfeld mit einer Bildlaufleiste zum Anzeigen von nur Text, ohne Eingabe und ein anderes Textfeld zum Übernehmen von Texteingaben vom Benutzer und dann eine Schaltfläche zum Senden des Textes für den Chat hinzufügen Aber auf meine Frage, wie fange ich überhaupt an, dies zu gestalten? Ich verstehe, dass ich ein Layout benötige, aber kann mir jemand dabei helfen? Hier ist mein Code im Moment (dieser Code richtet das Malen nur auf dem gesamten Bildschirm ein) im Moment muss der Bildschirm jetzt wie im obigen Bild aufgeteilt werden):

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);
     }
}

"new Display (start)" - dies erweitert das jpanel, in dem ich im Grunde alles grafisch male.

Außerdem habe ich gesehen, dass Leute in verschiedenen Panels hinzugefügt haben, aber ich kann nicht, dass sie die gleiche Größe haben. Wie auf dem Bild ist der Bereich "Grafik hier malen" der größte und so weiter.

15
Danny Dan

Das JPanel ist eigentlich nur ein Container, in den Sie verschiedene Elemente einfügen können (auch andere JPanels). In Ihrem Fall würde ich also einen großen JPanel als eine Art Hauptcontainer für Ihr Fenster vorschlagen. Das Hauptfenster Sie weisen ein Layout zu, das Ihren Anforderungen entspricht ( hier eine Einführung in die Layouts ).

Nachdem Sie das Layout auf Ihr Hauptfenster eingestellt haben, können Sie das Malfenster und die anderen gewünschten JPanels (wie die mit dem Text darin) hinzufügen. .

  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);

Dies ist nur ein Beispiel, das alle Unterfenster vertikal sortiert (Y-Achse). Wenn Sie also am unteren Rand Ihres Hauptfensters weitere Elemente (z. B. Symbole oder Schaltflächen) wünschen, die mit einem anderen Layout (z. B. einem horizontalen Layout) organisiert werden sollen, erstellen Sie einfach noch einmal ein neues JPanel als einen Container für alle anderen Sachen und setze setLayout(new BoxLayout(mainPanel, BoxLayout.X_AXIS).

Wie Sie herausfinden werden, sind die Layouts ziemlich starr und es kann schwierig sein, das beste Layout für Ihre Panels zu finden. Also nicht aufgeben, die Einleitung lesen (Link oben) und die Bilder anschauen - so mache ich das :)

Oder Sie können einfach NetBeans verwenden, um Ihr Programm zu schreiben. Dort haben Sie einen ziemlich einfachen visuellen Editor (Drag & Drop), um alle Arten von Windows und Frames zu erstellen. (Nur den Code danach zu verstehen, ist manchmal ... schwierig.)

BEARBEITEN

Da sich viele Menschen für diese Frage interessieren, wollte ich ein vollständiges Beispiel dafür geben, wie ein JFrame so gestaltet wird, dass es so aussieht, wie es OP möchte.

Die Klasse heißt MyFrame und erweitert Swings 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);
            }
        });
    }
}

Bitte beachten Sie, dass dies nur ein Beispiel ist und es mehrere Ansätze gibt, um ein Fenster zu gestalten. Es hängt alles von Ihren Bedürfnissen ab und davon, ob der Inhalt anpassbar sein soll. Ein weiterer wirklich guter Ansatz wäre das GridBagLayout , das recht komplexe Layouts verarbeiten kann, aber auch recht komplex zu erlernen ist.

27
GameDroids

Sie sollten eine Reihe von Layout-Managern verwenden, um die gewünschten grundlegenden Ergebnisse zu erzielen.

Schauen Sie sich Ein visueller Leitfaden für Layout-Manager für einen Vergleich an.

Sie können GridBagLayout verwenden, dies ist jedoch einer der komplexesten (und leistungsfähigsten) Layout-Manager, die im JDK verfügbar sind.

Sie können stattdessen eine Reihe von zusammengesetzten Layout-Managern verwenden.

Ich würde die Grafikkomponente und den Textbereich mit einem JPanel auf einem einzelnen BorderLayout platzieren, wobei die Grafikkomponente im CENTER und der Textbereich im SOUTH Position.

Ich würde das Textfeld und die Schaltfläche in einem separaten JPanel mit einem GridBagLayout platzieren (weil es das einfachste ist, was ich mir vorstellen kann, um das gewünschte Überergebnis zu erzielen).

Ich würde diese beiden Felder mit einem BorderLayout auf einem dritten Master-Feld platzieren, wobei sich das erste Feld an der CENTER und das zweite an der SOUTH Position befindet.

Aber das bin ich

1
MadProgrammer