Java Swing Probleme bei Erstellen einer Programm GUI

[DeusExMachina]

Swing Probleme (diverse Fragen)

Moin Moin,

der Java Noob schon wieder.

Ich soll ein Programm erstellen das diverse Eingaben über eine Swing UI ermöglicht (die genauen Funktionen sind erstmal neben sächlich) ich habe aber ein Problem ich will des Fenster (800x600) gern aufteilen aber ich finde nirgendwo eine Anleitung dazu.
javaswing soll genutzt werden.

Das Fenster wollte wie folgt aufgebaut haben:

Mit frame selbst geht das nicht und JDesktopPane verstehe ich ehrlich gesagt nicht genug um das gewünschte hin zu bekommen.

Wenn jemand mir vielleicht den grundaufbau erklären könnte oder nen guten link hat (sowas wie selfhtml für swing ) wäre mir schon sehr geholfen.


Und ne Frage noch wäre es besser die einzelnen Subframes als eigene Klassen zu schreiben oder lieber nur eine Große für die ganze UI und dann nur die Funktionen ein zu betten.

 

[sgenzel]

Stichwort ... LayoutManager ... ;-)

Ergänzung (10. November 2011)

... wenn Java auf dem Rechner installiert ist (wovon ich ausgehe), kannst Dir ja mal das Swing Demo hier anschauen ...

download.java.net/javadesktop/swingset3/SwingSet3.jnlp

 

[honky-tonk]

du kannst dir auch mal NetBeans anschauen...da fällt der einstieg echt einfach, per drag&drop

 

[DeusExMachina]

Ich benutze Eclipse und wir sollen des händisch machen.

Finde ich sowie so besser also Auto generierter Code aber schon mal danke für den link ich werd mir des mal ansehen.

 

[DasBoeseLebt]

Wenn du es ganz einfach ohne Schnickschnack und sonstigen Features machen willst, dann ist der folgende Aufbau einfach nur abtippen und einsetzen.

public class MainFrame extends JFrame

	private JButton button1;
	private JButton button2;

	public static void main(String[] args) {
		MainFrame start = new MainFrame();
	}

	public MainFrame() {
		this.initWindow();
		this.setSize( new Dimension(800, 600));
		this.setName("Cooles Fenster");
		this.setLocation(400,400);
	}

	private void initWindow() {
		button1 = new JButton("blubb");
		button2 = new JButton("blabb");

		button1.setBounds(5, 5, 100, 30);
		button2.setBounds(115, 5, 70, 30);

		this.getContentPane().add(button1);
		this.getContentPane().add(button2);

		this.pack();

	}
}

So fängt man eigentlich mit den ersten GUI's an. Schön ist aber was anderes.

Wenn du es schön haben willst, .. gehts in die Richtung Layoutmanager.

Hier ein kurzes Beispiel auch dazu

public class MainFrame extends JFrame

	private JButton button1;
	private JButton button2;

	public static void main(String[] args) {
		MainFrame start = new MainFrame();
	}

	public MainFrame() {
		this.initWindow();
		this.setSize( new Dimension(800, 600));
		this.setName("Cooles Fenster");
		this.setLocation(400,400);
	}

  private void initWindow() {
      setLayout(new GridBagLayout());
      GridBagConstraints constraints = new GridBagConstraints();

      constraints.fill = GridBagConstraints.NONE;
      constraints.anchor = GridBagConstraints.NORTHWEST;
      constraints.gridheight = 1;
      constraints.gridwidth = 1;
      constraints.weightx = 0;
      constraints.weighty = 0;
      constraints.insets = new Insets(INSET_SIZE, INSET_SIZE, INSET_SIZE, INSET_SIZE);

      constraints.gridx = 0;
      constraints.gridy = 0;

      constraints.gridwidth = 5;
      add(button1, constraints);
      constraints.gridx++;
      constraints.gridwidth = 2;
      add(button2, constraints);


      pack();
      }
}

Das Layout ist wie ein Gitter, ...sagt ja auch schon der Name und man hangelt sich mit x und y durch.. ... und ist für so ein GUI, wie du es willst , auch gut.

Und, ob du alles in eine Klasse knallst oder nicht, .. würde ich vom Umfang festmachen. Bei kleinen GUI's macht es einfach keinen Sinn alles in 1000Teile zu zerlegen, ....

ps: keine Ahnung, ob die Beispiele funktionieren oder das halbwegs brauchbar aussieht, da ich nicht passende Zahlen genommen hab bzw. irgendwelche.

 

[Rossie]

ich habe aber ein Problem ich will des Fenster (800x600) gern aufteilen aber ich finde nirgendwo eine Anleitung dazu.
javaswing soll genutzt werden.

Nach was hast Du denn gesucht? Bist Du dem Englischen einigermaßen mächtig?

Mit frame selbst geht das nicht und JDesktopPane verstehe ich ehrlich gesagt nicht genug um das gewünschte hin zu bekommen.

Wenn jemand mir vielleicht den grundaufbau erklären könnte oder nen guten link hat (sowas wie selfhtml für swing ) wäre mir schon sehr geholfen.

JDesktopPane würde ich für sowas nicht verwenden. Neben den bereits genannten LayoutManagern, die man auf jeden Fall braucht, würde ich den Einsatz von JSplitPanes für sinnvoll erachten. Im richtigen Leben wäre das ein Fall für ein Docking Framework.

Frame
Layout Manager
Menü
Toolbar
SplitPane

Die Artikel hinter den Links enthalten viele lauffähige Beispiele. Lesen, ausprobieren, verstehen, anwenden.

Und ne Frage noch wäre es besser die einzelnen Subframes als eigene Klassen zu schreiben oder lieber nur eine Große für die ganze UI und dann nur die Funktionen ein zu betten.

Für diesen simplen Fall reicht sicher eine Klasse. Grundsätzlich sollte man den Code so strukturieren, dass er gut verständlich und leicht zu warten ist.

 

[DeusExMachina]

Nach was hast Du denn gesucht? Bist Du dem Englischen einigermaßen mächtig?

Hauptsächlich nach JFrame und Swing UI (mit zusätzen wie Commands oder Guide) so ab der dritten Seite schleichen sich dann langsam aber noch andere Swingende Tätigkeiten mit in die Suche und die sind nicht wirklich themen bezogen.

Und leider hat man zu oft Foren Treffer die einem dazwischen fuschen.


Zu SplitPane das schon ok nur leider brauch ichs fest und ohne Borders.

 

[DeusExMachina]

ich hab mir des mit dem GridBagLayout mal angesehen und das scheint mir das richtige zu sein nur ganz verstehen wie das Funktioniert tue ich noch nicht.

Die werte für rows und colums stelle ich doch über GridBagLayout() ein oder?

muss ich wenn ich diese ändern will eine neue GridBagLayout() erstellen die die Vordefinierte ersetzt oder reicht da ein Aufruf?

ich glaub ich mach mir das viel zu kompliziert bei Verstehen.

ich würde gern die einzelnen Felder auf 10x10 pixel setzen und dann den einzelnen buttons und feldern einfach immer einen Bereich zu ordnen.
Aber irgendwas macht da grad noch nicht klick.

 

[Tumbleweed]

Mach dir nichts daraus... es ist tatsächlich nicht so einfach zu verstehen. Wird auch gern an Java bemängelt, dass GUI-Bau so ist, wie es eben ist.

Beispiel für deinen Fall:

public class Sandbox extends JFrame
{

    public Sandbox(final int width, int height)
    {
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setLayout(new BorderLayout());
        setMinimumSize(new Dimension(width, height));
        setBounds(Toolkit.getDefaultToolkit().getScreenSize().width / 2 - width / 2, Toolkit.getDefaultToolkit().getScreenSize().height / 2 - height
                    / 2, width, height);
        
        add(new JPanel()
        {{
            setPreferredSize(new Dimension(width, 50));
            setBackground(Color.orange);
        }}, BorderLayout.PAGE_START);
        
        add(new JPanel()
        {{
            setPreferredSize(new Dimension(width, 50));
            setBackground(Color.black);
            setLayout(new GridBagLayout());
            GridBagConstraints gc = new GridBagConstraints();
            
            gc.gridx = 0;
            gc.gridy = 0;
            gc.fill = GridBagConstraints.BOTH;
            add(new JPanel()
            {{
                setBackground(Color.green);
                setPreferredSize(new Dimension(550, 400));
            }}, gc);
            
            gc.gridx = 0;
            gc.gridy = 1;
            add(new JPanel()
            {{
                setBackground(Color.gray);
                setPreferredSize(new Dimension(550, 100));
            }}, gc);
            
            gc.gridx = 1;
            gc.gridy = 0;
            gc.gridheight = 2;
            gc.ipady = 10;
            add(new JPanel()
            {{
                setBackground(Color.cyan);
                setPreferredSize(new Dimension(234, 500));
            }}, gc);
            
        }}, BorderLayout.CENTER);
        
        setVisible(true);
    }
    
    public static void main(String[] args)
    {
        new Sandbox(800, 600);
    }
}

Mit dem contraints-Objekt musst du vorsichtig sein. Wie du siehst kannst du theoretisch für alle das gleiche verwenden und zwischendrin einfach die Werte ändern. Darfst dich nur nicht verzetteln dabei.

 

[DeusExMachina]

ich verstehe das richtig das du jetzt einfach Flächen (in form von jpanels) in das hauptpanel rein gelegt hast?

Funzt das auch mit Funktionen?

 

[Tumbleweed]

Ja richtig, die JPanels werden da einfach reingeklatscht. Diese JPanels könnten übrigens wiederum andere Layout manager verwenden, je nach Bedarf.

Was meinst du mit Funktionen? Funktionen sind ja keine sichtbaren Elemente. Versteh dich wohl falsch

 

[DeusExMachina]

Ich meinte Buttons und der gleichen.

In den Grünen bereich soll ja eine Grafische Anzeige für Ergenisse kommen.

Der Graue Bereich enthält sowohl checkboxes als auch Textelement.

Mir geht es darum zu verstehen wie ich die Fläche entsprechend einteilen kann

Des Fenster und die Menübar waren nicht das Thema (womit Orange entfällt)

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

public class MainMenu {

	JFrame mainMenu;

	MainMenu() {
		JFrame mainMenu = new JFrame("Rechner");

		//frame properties
		mainMenu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		mainMenu.setSize(800, 600);
		mainMenu.setLocation(50, 50);
		mainMenu.setResizable(false);
		mainMenu.setVisible(true);

		//Create the menu bar.
		JMenuBar menuBar = new JMenuBar();
		mainMenu.setJMenuBar(menuBar);
				
		// Create menu.
		JMenu fileMenu = new JMenu("File");
		menuBar.add(fileMenu);
		fileMenu.add(new JMenuItem("Open"));
		fileMenu.add(new JMenuItem("Save"));
		fileMenu.add(new JMenuItem("Close"));
		
		

	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		new MainMenu();

	}

}

Blöde frage übrigens wie ist des mit mit der Menubar wird deren Breite von den 800x600 abgezogen? was ist eigentlich 800x600 der Innere Bereich (also alles innerhalb des Fensterrahmens) oder die Äussere Grenze des Fensters?

Ich will nur den Bereich den ich unterhalb der menubar so einteilen das ich genau weiß wo welches Item ist damit ich die recht komplexe UI einprogrammieren kann.

Und ich bin kurz vorm verzweifeln da ich dieses Bekloppe swing nicht verstehe.

 

[Tumbleweed]

Die 800x600 sind das ganze Fenster, also inklusive Rahmen. Wenn du darin ein 800x600 Bild zeichnest, wird es teilweise nicht sichtbar sein. Ich vermute mal die JMenuBar nimmt sich auch einfach ihren Teil vom Kuchen weg, das müsste ich aber selbst probieren.

Kleiner Tipp am Rande: wenn es dir darum geht ganz genau zu sagen wo sich was befindet und du dein Fenster ohnehin resizable(false) hast, dann kannst du auch einfach setLayout(null) machen und dann mit absoluten Positionsangaben für alle Elemente arbeiten. Der Layout Manager ist vor allem dann interessant, wenn sich die Fenstergröße ändern kann.

Ach und ja, natürlich kannst du innerhalb der JPanels auch Buttons usw. adden. Könntest dann einem der JPanels z.B. ein GridLayout geben und die Knöpfe dann darin anordnen.

 

[DeusExMachina]

wie geht das dann mit den absoluten werten?

Ich raff da grad irgend was nicht vielleicht ist es auch schon zu spät ich sitz das seit 10std dran wühl mich durch zich tuts und seiten und es macht einfach nicht klick

 

[Tumbleweed]

Das sieht dann z.B. so aus:

package playground;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Toolkit;

import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JPanel;


@SuppressWarnings("serial")
public class Sandbox extends JFrame
{

    public Sandbox(final int width, int height)
    {
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setLayout(new BorderLayout());
        setMinimumSize(new Dimension(width, height));
        setBounds(Toolkit.getDefaultToolkit().getScreenSize().width / 2 - width / 2, Toolkit.getDefaultToolkit().getScreenSize().height / 2 - height
                    / 2, width, height);
        
        add(new JPanel()
        {{
            setPreferredSize(new Dimension(width, 50));
            setBackground(Color.orange);
        }}, BorderLayout.PAGE_START);
        
        add(new JPanel()
        {{
            setPreferredSize(new Dimension(width, 50));
            setBackground(Color.black);
            setLayout(new GridBagLayout());
            GridBagConstraints gc = new GridBagConstraints();
            
            gc.gridx = 0;
            gc.gridy = 0;
            gc.fill = GridBagConstraints.BOTH;
            add(new JPanel()
            {{
                setBackground(Color.green);
                setPreferredSize(new Dimension(550, 400));
            }}, gc);
            
            gc.gridx = 0;
            gc.gridy = 1;
            add(new JPanel()
            {{
                setBackground(Color.gray);
                setPreferredSize(new Dimension(550, 100));
            }}, gc);
            
            gc.gridx = 1;
            gc.gridy = 0;
            gc.gridheight = 2;
            gc.ipady = 10;
            add(new JPanel()
            {{
                setBackground(Color.cyan);
                setPreferredSize(new Dimension(234, 500));
                setLayout(null);
                
                add(new JButton("crazy button")
                {{
                    setBounds(50, 25, 120, 20);
                }});
                
                add(new JButton("moar crazy")
                {{
                    setBounds(85, 55, 120, 40);
                }});
                
                add(new JCheckBox("check me out")
                {{
                    setBounds(60, 155, 120, 40);
                }});
                
            }}, gc);
            
        }}, BorderLayout.CENTER);
        
        setVisible(true);
    }
    
    public static void main(String[] args)
    {
        new Sandbox(800, 600);
    }
}

 

[Rossie]

Ich würde Dir empfehlen, NICHT mit absoluten Werten zu hantieren. Programmfenster sollten so gut wie immer vom Benutzer an die gewünschte Größe angepasst werden können und der Inhalt sich automatisch entsprechend anpassen. Ansonsten können wenn es schlecht läuft, schon unterschiedliche Systemschriften Dein Layout zerstören! Das ist ganz schlechter Stil!

Wenn Dir GridBagLayout zu kompliziert ist, verwende einfachere Layout-Manager. Damit kann man durch Verschachtelung auch kompliziertere Layouts umsetzen.

public class Example
{
    private static final int MAIN_WIDTH = 550;
    private static final int MAIN_HEIGHT = 600;

    public static void main(final String... rArgs)
    {
        // all Swing code must be executed in the event dispatch thread (EDT)
        SwingUtilities.invokeLater(new Runnable()
            {
                public void run()
                {
                    new Example().startup();
                }
            });
    }


    private JComponent buildContentPane()
    {
        JPanel content = new JPanel();
        content.setLayout(new BorderLayout());
        content.add(buildGraphicsPane(), BorderLayout.CENTER);
        content.add(buildMessagePane(), BorderLayout.SOUTH);

        return content;
    }


    private JPanel buildControlPane()
    {
        JPanel blue = new JPanel();
        blue.setPreferredSize(new Dimension(250, MAIN_HEIGHT));
        blue.setBackground(Color.BLUE);

        return blue;
    }


    private JComponent buildGraphicsPane()
    {
        JComponent green = new JPanel();
        green.setPreferredSize(new Dimension(MAIN_WIDTH, 400));
        green.setBackground(Color.GREEN);

        return green;
    }


    private JPanel buildMainPane()
    {
        JPanel second = new JPanel();
        second.setLayout(new BorderLayout());
        second.add(buildContentPane(), BorderLayout.CENTER);
        second.add(buildControlPane(), BorderLayout.EAST);

        return second;
    }


    private JComponent buildMessagePane()
    {
        JComponent gray = new JPanel();
        gray.setPreferredSize(new Dimension(MAIN_WIDTH, 150));
        gray.setBackground(Color.GRAY);

        return gray;
    }


    private void startup()
    {
        JFrame frame = new JFrame("MyFrame");
        frame.addWindowListener(new WindowAdapter()
            {
                @Override
                public void windowClosing(final WindowEvent rEvent)
                {
                    System.exit(0);
                }
            });
        frame.getContentPane().add(buildMainPane());
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
    }
}

Wenn Du das Fenster jetzt in der Größe veränderst, wird Du feststellen, dass sich der grüne Bereich entsprechend anpasst. Man könnte auch die anderen Bereiche entsprechend mitwachsen lassen. Da muss man halt das Verhalten der verwendeten Layout-Manager entsprechend kennen und ausnutzen bzw. diese entsprechend konfigurieren. Nicht nur deswegen empfehlen sich gleich leistungsfähige Layout-Manager wie MigLayout oder JGoodies.

Ach ja, ein Punkt, den anscheinend nicht nur in diesem Forum viele immer wieder vergessen oder nicht wissen: Swing Code immer im EDT ausführen (es gibt zwei, drei Ausnahmen, wo dies nicht notwendig ist, aber die kann man ignorieren).

Ergänzung (14. November 2011)

Die einzelnen Panes bestückst Du dann mit den eigentlichen Elementen (Buttons, Textfelder etc.). Analog zum obigen Beispiel, die einzelnen Elemente einfach immer weiter runterbrechen. Mit besseren Layout-Managern vereinfacht sich der Code, weil man nicht sp viel verschachteln muss. Die grundsätzliche Herangehensweise bleibt sich gleich.

 

[don.dope]

Was LayoutManager angeht kann ich an dieser Stelle nur wärmstens das FormLayout von JGoodies empfehlen.

Hier noch der Downloadlink

Und noch ein Artikel, wie das ganze funktioniert.

Für Detailfragen einfach PN an mich.

Damit lässt sich das gewünschte Layout relativ einfach mit eine paar Zeilen bauen:

private JComponent buildContent() {
	FormLayout layout = new FormLayout(
		"fill:400dlu:grow, fill:100dlu:grow", 
		"f:25dlu:g, f:400dlu:g, f:50dlu:g");
	PanelBuilder builder = new PanelBuilder(layout);
	builder.add(menubarPanel,  CC.xyw (1, 1, 2));
	builder.add(graphicsPanel, CC.xy  (1, 2));
	builder.add(controlsPanel, CC.xywh(2, 2, 1, 2));
	builder.add(bottomPanel,   CC.xy  (1, 3));
	return builder.getPanel();
}

Ein mögliches Resultat sähe dann wie folgt aus:

 

[Rossie]

Was bei FormLayout und mehr noch bei MigLayout bedenkenswert ist, ist die Tatsache, dass diese auch für andere Toolkits (z.B. SWT, JavaFX) zur Verfügung stehen. Der Lernaufwand kann sich also in mehrfacher Hinsicht rentieren. Die Verwendung von Swing wird wohl weiter zurückgehen in Zukunft. Hilft natürlich nicht, wenn man eine Aufgabe zwingend mit den Bordmitteln lösen muss

 

[DeusExMachina]

Richtig.

Aber ich werde mir die angesprochenen Tools mal beizeiten ansehen (danke für den Tipp).

Da ich noch nicht dazu gekommen bin bedanke ich mich erst mal bei allen für ihre Hilfe.

Wir haben das ganze soweit so realisiert:

package aufgabe3;

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;
import javax.swing.event.*;

public class MainMenu implements ActionListener, ListSelectionListener {
	private static final int MAIN_WIDTH = 800;
	private static final int MAIN_HEIGHT = 600;
	private DefaultListModel listModel;

	public static void main(final String... rArgs) {
		new MainMenu().startup();
	}

	private JPanel buildMainPanel() {
		JPanel mainPanel = new JPanel();
		mainPanel.setLayout(new BorderLayout());
		mainPanel.add(buildContentPane(), BorderLayout.CENTER);
		mainPanel.add(buildSidebarPane(), BorderLayout.EAST);

		return mainPanel;
	}

	private JComponent buildContentPane() {
		JPanel contentPane = new JPanel();
		contentPane.setLayout(new BorderLayout());
		contentPane.add(buildGraphicPanel(), BorderLayout.CENTER);
		contentPane.add(buildResultPanel(), BorderLayout.SOUTH);

		return contentPane;
	}

	private JComponent buildSidebarPane() {
		JPanel sidebarPane = new JPanel();
		sidebarPane.setLayout(new BorderLayout());
		sidebarPane.add(buildListPanel(), BorderLayout.NORTH);
		sidebarPane.add(buildControlPanel(), BorderLayout.SOUTH);

		return sidebarPane;
	}

	private JPanel buildListPanel() {
		JPanel listPanel = new JPanel();
		listModel = new DefaultListModel();
		JList list = new JList(listModel);
		JScrollPane scrollPane = new JScrollPane(list);
		scrollPane.setPreferredSize(new Dimension(240, ((2 * MAIN_HEIGHT / 3) - 10)));
		listPanel.add(scrollPane);
		listPanel.setPreferredSize(new Dimension(250, (2 * MAIN_HEIGHT / 3)));

		return listPanel;
	}

	/**Eingabe und Steuerfeld
	 * 
	 * @return ControlPanel
	 */
	private JPanel buildControlPanel() {
		JPanel controlPanel = new JPanel(new GridBagLayout());
		GridBagConstraints gridBagConstraints = new GridBagConstraints();

		// Erstellen der Buttons und ihrer Funktion
		//Load Button
		JButton loadButton = new JButton("Load");
		loadButton.setToolTipText("Liste Laden");
		loadButton.addActionListener(this);
		loadButton.setActionCommand("Load");
		loadButton.setMnemonic('o');
		
		//Save Button
		JButton saveButton = new JButton("Save");
		saveButton.setToolTipText("Liste Speichern");
		saveButton.addActionListener(this);
		saveButton.setActionCommand("Save");
		saveButton.setMnemonic('a');
		
		//Eingabe Felder
		JTextField realTextField = new JTextField(10);
		JLabel label = new JLabel("+ j *");
		JTextField imagTextField = new JTextField(10);
		
		//Add Button
		JButton addButton = new JButton("Add");
		addButton.setToolTipText("Eingegebene Zahl hinzufügen");
		addButton.addActionListener(this);
		addButton.setActionCommand("Add");
		addButton.setMnemonic('d');
		
		//AddRandom Button
		JButton addRandomButton = new JButton("AddRandom");
		addRandomButton.setToolTipText("Eine Zufällige Zahl hinzufügen");
		addRandomButton.addActionListener(this);
		addRandomButton.setActionCommand("AddRandom");
		addRandomButton.setMnemonic('R');
		
		//Delete Button
		JButton deleteButton = new JButton("Delete");
		deleteButton.setToolTipText("Delete selected");
		deleteButton.addActionListener(this);
		deleteButton.setActionCommand("Del");
		
		//Delete All Button
		JButton deleteAllButton = new JButton("Delete All");
		deleteAllButton.setToolTipText("Clear List");
		deleteAllButton.addActionListener(this);
		deleteAllButton.setActionCommand("DelAll");

		// Textfeld für die Eingabe des Realanteils
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 1;
		gridBagConstraints.gridheight = 1;
		gridBagConstraints.gridx = 0;
		gridBagConstraints.gridy = 0;
		controlPanel.add(realTextField, gridBagConstraints);

		// Label für J *
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 1;
		gridBagConstraints.gridx = 1;
		gridBagConstraints.gridy = 0;
		controlPanel.add(label, gridBagConstraints);

		// Textfeld für die Eingabe des Imaginäranteils
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 1;
		gridBagConstraints.gridx = 3;
		gridBagConstraints.gridy = 0;
		controlPanel.add(imagTextField, gridBagConstraints);

		// Der Addbutton
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 2;
		gridBagConstraints.gridx = 0;
		gridBagConstraints.gridy = 1;
		controlPanel.add(addButton, gridBagConstraints);

		// Addrandom Button
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 2;
		gridBagConstraints.gridx = 2;
		gridBagConstraints.gridy = 1;
		controlPanel.add(addRandomButton, gridBagConstraints);

		// Delete selected Button
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 2;
		gridBagConstraints.gridx = 0;
		gridBagConstraints.gridy = 2;
		controlPanel.add(deleteButton, gridBagConstraints);

		// Clear List Button
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 2;
		gridBagConstraints.gridx = 2;
		gridBagConstraints.gridy = 2;
		controlPanel.add(deleteAllButton, gridBagConstraints);

		// Load
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 2;
		gridBagConstraints.gridx = 0;
		gridBagConstraints.gridy = 3;
		controlPanel.add(loadButton, gridBagConstraints);

		// Save
		gridBagConstraints.fill = GridBagConstraints.HORIZONTAL;
		gridBagConstraints.gridwidth = 2;
		gridBagConstraints.gridx = 3;
		gridBagConstraints.gridy = 3;
		controlPanel.add(saveButton, gridBagConstraints);

		controlPanel.setPreferredSize(new Dimension(250, 100));
		return controlPanel;
	}

	private JComponent buildGraphicPanel() {
		JComponent graphicPanel = new JPanel();
		graphicPanel.setPreferredSize(new Dimension(MAIN_WIDTH, MAIN_HEIGHT));
		graphicPanel.setBorder(BorderFactory.createLineBorder(Color.BLACK, 2));
		return graphicPanel;
	}

	private JComponent buildResultPanel() {
		JComponent resultPanel = new JPanel(new GridLayout(2, 3, 5, 0));
		JCheckBox checkSumme = new JCheckBox("Summe: ", true);
		JCheckBox checkDifferenz = new JCheckBox("Differenz: ");
		JCheckBox checkBoxProdukt = new JCheckBox("Produkt: ", true);
		JCheckBox checkBoxQuotient = new JCheckBox("Quotient: ");
		JLabel checkBoxBetrag = new JLabel("Betrag: ");
		JLabel checkBoxPhase = new JLabel("Phase: ");
		resultPanel.add(checkSumme);
		resultPanel.add(checkDifferenz);
		resultPanel.add(checkBoxBetrag);
		resultPanel.add(checkBoxProdukt);
		resultPanel.add(checkBoxQuotient);
		resultPanel.add(checkBoxPhase);
		resultPanel.setPreferredSize(new Dimension(MAIN_WIDTH, 100));

		return resultPanel;
	}

	/**Erstellen der Menueleiste
	 * 
	 * @return menuBar
	 */
	private JMenuBar createMenuBar() {
		JMenuBar menuBar = new JMenuBar();
		JMenu fileMenu = new JMenu("File");
		fileMenu.setMnemonic('F');
		JMenuItem load = new JMenuItem("Load");
		JMenuItem save = new JMenuItem("Save");
		JMenuItem exit = new JMenuItem("Exit");

		menuBar.add(fileMenu);
		fileMenu.add(load);
		load.addActionListener(this);
		load.setActionCommand("Load");
		load.setMnemonic('L');
		fileMenu.add(save);
		save.addActionListener(this);
		save.setActionCommand("Save");
		save.setMnemonic('S');
		fileMenu.addSeparator();
		fileMenu.add(exit);
		exit.addActionListener(this);
		exit.setActionCommand("Exit");
		exit.setMnemonic('E');

		return menuBar;
	}

	private void startup() {
		JFrame frame = new JFrame("Complex Solutions");
		frame.setResizable(false);
		frame.setJMenuBar(createMenuBar());
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(MAIN_WIDTH, MAIN_HEIGHT);

		frame.add(buildMainPanel());
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
	}

	@Override
	public void valueChanged(ListSelectionEvent arg0) {

	}

	@Override
	public void actionPerformed(ActionEvent arg) {
		if ("Load".equals(arg.getActionCommand()))
			System.out.println("Load");
		else if ("Save".equals(arg.getActionCommand()))
			System.out.println("Save");
		else if ("Add".equals(arg.getActionCommand()))
			System.out.println("Add");
		else if ("AddRandom".equals(arg.getActionCommand()))
			System.out.println("AddRandom");
		else if ("Del".equals(arg.getActionCommand()))
			System.out.println("Del");
		else if ("DelAll".equals(arg.getActionCommand()))
			System.out.println("DelAll");
	}

	 private void addNumber() {
	 try {
	 double real = Double.valueOf(realTextField.getText());
	 double imag = Double.valueOf(imaginary_txt.getText());
	 Complex newComplexNumber = new Complex(real, imag);
	 if (listModel.contains(newComplexNumber.toString()) == false) {
	 numberList.add(newComplexNumber);
	 listModel.addElement(newComplexNumber.toString());
	 cs.setSelectedIndicesArray(list.getSelectedIndices());
	 cs.repaint();
	 } else {
	 JOptionPane.showMessageDialog(null,
	 "You can't enter the same number twice", "Error",
	 JOptionPane.INFORMATION_MESSAGE);
	 }
	 } catch (NumberFormatException e) {
	 JOptionPane.showMessageDialog(null,
	 "You entered an invalid number", "Error",
	 JOptionPane.INFORMATION_MESSAGE);
	 }
	 }
	
}

Ein paar fragen hab ich aber noch:

Ich habe ja eine Liste und möchte nur aber nur maximal zwei Listen einträge auswählen lassen (ich meine im Swing Buch gelesen zu haben das geht aber finde des aber grad nich wieder und das buch ist verdammt dick)

Ich würde gern und das ist dann auch der Knackpunkt des ganzen das sohand haben das:

- Maximal 2 zahlen in der liste gewählt werden dürfen
- Ihre Reinfolge fest legt ob sie z1 oder z2 sind
- wenn eine neue Zahl gewählt wird z2 zu z1 wird (was ich denke einfach über eine If abfrage realisieren zu lassen sollte )


Und die Zweite Frage wie kann ich die Ausgabe von double Zahlen auf 4 nachkomma stellen begrenzen.

 

[DasBoeseLebt]

Ich habe ja eine Liste und möchte nur aber nur maximal zwei Listen einträge auswählen lassen (ich meine im Swing Buch gelesen zu haben das geht aber finde des aber grad nich wieder und das buch ist verdammt dick)

Ein DefaultListModel unterstützt das nicht, du müsstest eine JList benutzen.


Du kannst das dann wie folgt machen:

DefautListModel dlm = new DefaultListModel(); // generics jetz ma außen vor
/**
normal die dlm füellen
...
...
*/
JList list = new JList(dlm);
list.setSelectMode(ListSelectModel.MULTIPLE_INTERVAL_SELECTION);
list.setLayoutOrientation(JList.VERTICAL);

Den Rest müsstest du mit einem ListSelectionListener machen, dass er max. 2 aufnimmt und den Rest dann rauswirft... oder so...

class MyListSelectionListener implements ListSelectionListener {
// wird immer aufgerufen, wenn sie die Selection ändern..
    public void valueChanged(ListSelectionEvent evt) {
        if (!evt.getValueIsAdjusting()) {
            JList list = (JList)evt.getSource();

            Object[] selected = list.getSelectedValues();
            //wenn mehr als 3.. dann wirf das erste wieder raus und nehm die letzten 2....
            // musst du halt mit den letzten vergleichen oder dir i-wie merken.

        }
    }
}

http://download.oracle.com/javase/tutorial/uiswing/components/list.html



// Dein Double-Problem kannst du sehr einfach lösen.

double dasistnichtpi = 213123123123123.123123123;
DecimalFormat df = new DecimalFormat("#0.0000");
System.out.println(df.format(dasistnichtpi).replace(",",".");
dasistnichtpi = Double.parseDouble(df.format(dasistnichtpi).replace(",","."));

Er macht aus dem . ein , ... da musste aufpassen, deshalb replace.
Und es ist dann ein String, ... wenn du es wieder in eine Double haben willst, dann solltest du das replacen beibehalten