mehrfaches Öffnen eines JInternalFrame verhindern

[Gast]

Hi@all!

Ich habe eine kleines Programm mit einer Menüleiste und einem Menü 'Anwendungen'. Hier kann man zwischen einem Taschenrechner und einem Zinsrechner auswählen, die nach anklicken instantiiert und in einem InternalFrame angezeigt werden. Mein Problem: wenn bspw. der Taschenrechner schon angezeigt wird, soll es nicht mehr möglich sein, einen weiteren Taschenrechner anzuzeigen, sondern nur noch zusätzlich den Zinsrechner. Bis jetzt ist es so, dass beliebig viele Taschenrechner-Fenster aufgehen, wenn man wiederholt auf den Menüpunkt klickt. Das möchte ich nun unterdrücken, weiss aber leider nicht, wie ich das anstellen soll.

Ich danke euch für eure Hilfe!

Viele Grüße,
Reini

 

[Wildcard]

Schau dir mal das Singelton Pattern an...

 

[Gast]

Supi, danke Wildcard! Und Kompliment an deathbyaclown für diesen genialen Beitrag. Endlich mal Design-Patterns kurz und knackig erklärt! Klasse!
Viele Grüße,
Reini

 

[Gast]

Das Prinzip eines Singletons habe ich jetzt verstanden. Trotzdem will es noch nicht so richtig funktionieren. Wenn ich mein internes Fenster geöffnet habe und den Menüeintrage erneut anklicke, wird eine IllegalArgumentException: illegal component position geworfen (siehe Kommentar im Code). Danke im voraus!!

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

public class IntFrameApp {
    public static void main(String args[]) {
        Hauptfenster fenster = new Hauptfenster();
        fenster.setSize(500, 500);
        fenster.setVisible(true);
    }
}

class Hauptfenster extends JFrame implements ActionListener {
    
    private JDesktopPane desktop;
    private JMenuBar     menuBar;
    private JMenu        menu;
    private JMenuItem    menuItem;
    
    public Hauptfenster() {
        super("Hauptfenster");
        this.desktop = new JDesktopPane();
        desktop.setDesktopManager(new DefaultDesktopManager());
        setContentPane(desktop);
        addWindowListener(new WindowClosingAdapter(true));
        
        menuBar  = new JMenuBar();
        menu     = new JMenu("Anwendungen");
        menuItem = new JMenuItem("Anwendung1");
        menuItem.addActionListener(this);
        menu.add(menuItem);
        menuBar.add(menu);
        setJMenuBar(menuBar);
    }
    
    public void actionPerformed(ActionEvent event) {
        if (event.getActionCommand().equals("Anwendung1")) {
            showInternalFrame(Kindfenster.getIntFrameInstance(), 100, 100);
        /* wenn das Kindfenster schon geöffnet ist und erneut auf Anwendung1
         * geklickt wird, was wird dann von getIntFrameInstance zurück geliefert?
         * hier mache ich imo was falsch. muss ich zusätzlich verhindern, dass
         * showInternalFrame dann ausgeführt wird?
         */
        }
    }
    
    public void showInternalFrame(JInternalFrame internalFrame, int posX, int posY) {
        internalFrame.setLocation(posX, posY);
        internalFrame.setSize(150, 100);
        internalFrame.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);
        desktop.add(internalFrame);
        desktop.revalidate();
        internalFrame.setVisible(true);
    }    
}

class Kindfenster extends JInternalFrame {
    
    // implementiert als Singleton
    private static Kindfenster intFrameInstance = null;    
    public  static Kindfenster getIntFrameInstance() {
        if (intFrameInstance == null) {
            intFrameInstance = new Kindfenster();
        }
        return intFrameInstance;
    }
    
    // Konstruktor
    private Kindfenster() {
        super("Kindfenster");
        setClosable(true);
    }
}

 

[Roar]

du versuchst deinen internalframe ein zweitesmal deiner jdesktoppane hinzuzufügen, darum der fehler

 

[Gast]

Was ich nicht richtige verstehe, ist folgendes: Das Singleton sorgt dafür, dass der IntFrame nur einmal erzeugt werden kann. Bedeutet das:
a) dass er nach dem schließen zwar nicht mehr angezeigt wird, aber trotzdem noch existiert, wenn ja, wie füge ich ihn dann erneut ein?
oder b) wenn der IntFrame geschlossen wird, dann gibts auch die Instanz nicht mehr (== null) und ich muss/kann beim nächsten Mal eine neue erzeugen??
Kurz gesagt: Wenn ich den InternalFrame schließe und später wieder öffnen will, dann muss ich ihn wieder in DesktopPane einfügen. Wenn er bereits angezeigt wird, muss ich dies verhindern. An dieser Stelle komme ich nicht weiter.

 

[Roar]

hö?
wenn du deinen internalframe schliesst wird er noch lange nicht aus dem speicher gelöscht

 

[Gast]

aha, langsam lichtet sich die sache. könnte es dann so klappen: ich erzeuge den intframe außerhalb des eventhandlers und setze ihn auf setVisible(false). im eventhandler muss ich überprüfen, ob visible==false -wenn ja, auf true setzen- oder visible==true -dann gar nix machen. dann stellt sich mir allerdings die frage, ob ich für meinen fall überhaupt ein singleton benötige. das müsste dann doch auch ohne gehen, weil ich den intframe doch nur einmal instantiiere?

 

[Roar]

jo wenn du ihn nur einmal instantiierst.
du kannst aber auch einfach mit JDesktopFrame#containsFrame() (oder so) überprüfen ob der frame angezeigt wird, ist vielleicht sicherer...

 

[Gast]

Also, öffnen kann ich das IntFrame nach dieser kleinen Änderung jetzt nur noch einmal, wie schön!
Aaaber, wenn ich ein geöffnetes Fenster verschiebe und dann noch mal den Menüpunkt anklicke, springt es mir wieder an die ursprüngliche Stelle zurück.. das ist nicht schön. Hab versucht mit getPosition dies zu verhindern - Fehlanzeige. Bei einer zweiten Variante kann bleibt das Fenster zwar an der Position an die es verschoben wurde, aber es lässt sich nach dem schließen kein weiteres mal öffnen...ich krieg die Krise!!

// VARIANTE NR.1
    
    private boolean intFrameVisible = false;
    
    public void actionPerformed(ActionEvent event) {
        if (event.getActionCommand().equals("Anwendung1")) {            
            if (!intFrameVisible) {                
                showInternalFrame(Kindfenster.getIntFrameInstance(), 100, 100);
            }
        }
    }
    
    public void showInternalFrame(JInternalFrame internalFrame, int posX, int posY) {        
        internalFrame.setLocation(posX, posY);
        internalFrame.setSize(150, 100);        
        internalFrame.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);
        desktop.add(internalFrame); 
        intFrameVisible = true;
        internalFrame.setVisible(true);
     
     /* Erg.: Fenster lässt sich zwar nur einmal Öffnen, bleibt nach verschieben
      * an seiner Position, aber nach dem schließen kann es nicht mehr geöffnet werden
      */

// VARIANTE NR.2
           
    public void actionPerformed(ActionEvent event) {
        if (event.getActionCommand().equals("Anwendung1")) {                                   
                showInternalFrame(Kindfenster.getIntFrameInstance(), 100, 100);            
        }
    }
    
    public void showInternalFrame(JInternalFrame internalFrame, int posX, int posY) {        
        internalFrame.setLocation(posX, posY);
        internalFrame.setSize(150, 100);        
        internalFrame.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);             
     
        if (!internalFrame.isVisible()) {
            desktop.add(internalFrame);        
            internalFrame.setVisible(true);
        
        /* es folgt der Versuch ein geöffnetes IntFrame welches verschoben wurde
        * an seiner momentanen Position zu belassen..
        * geht nicht! es springt wieder an posX, posY (100,100) zurück..
        * immerhin kann man es aber nach dem schließen wieder öffnen
        */
        } else internalFrame.setLocation(internalFrame.getLocation());
    }

Optimal wäre jetzt eine Mischung aus beiden Varianten, aber wie??

 

[Gast]

Anmerkung zum Kommentar in Var. 1: mit 'nur einmal Öffnen' meine ich, dass bei einem geöffnten Fenster kein weiteres aufgemacht werden kann (funktioniert in beiden Var)

 

[Gast]

Hurra, es klappt! Habe einen ComponentListener hinzugefügt, der die neue Position des InternalFrame abfragt. D.h. jetzt kann bei einem geöffneten InternalFrame kein weiterer aufgemacht werden, wenn der geöffnete Frame verschoben wurde bleibt er auch da wo er ist, falls versucht wird einen weiteren zu öffnen und schließlich, falls der IntFrame geschlossen wurde, erscheint beim erneuten Öffnen der neue Frame an der Stelle, wo der alte geschlossen wurde..wie im wirklichen Leben! Für alle, die es interessiert, hier die verbesserte Version:

private int posX = 100;
    private int posY = 100;
    
    public void actionPerformed(ActionEvent event) {
        if (event.getActionCommand().equals("Anwendung1")) {            
                showInternalFrame(Kindfenster.getIntFrameInstance(), posX, posY);                
        }
    }
    
    public void showInternalFrame(JInternalFrame internalFrame, int posX, int posY) {        
        internalFrame.setLocation(posX, posY);
        internalFrame.setSize(150, 100);        
        internalFrame.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);             
     
        if (!internalFrame.isVisible()) {       // nur beim allerersten Öffnen!
            desktop.add(internalFrame);                 
            internalFrame.setVisible(true);
            internalFrame.addComponentListener(new MyComponentListener());
            System.out.println(internalFrame.getLocation());
        }
    }
    
    class MyComponentListener extends ComponentAdapter {
        
        // InternalFrame wurde verschoben, speichere neue Position
        public void componentMoved(ComponentEvent event) {
            posX = event.getComponent().getX();
            posY = event.getComponent().getY();
        }
    }