HILFE! - per ActionListener Felder enablen.......

[uwe_P]

Hallo zusammen,
ich bin am verzweifeln.
Ich habe in meinem Programm meherer JLabel, JTextfelder usw.....
Jetzt habe ich als boolean-Wert in setEnabled(bo_weiter) eine Variable bo-weiter eingesetzt.

Jetzt möchte ich diese Variable aus dem ActionListener eines JButtons ändern. Das bekomme ich aber nicht hin. Mir fällt auch keine Lösung mehr ein. Ich möchte ungern jedes Textfeld und jedes Label im ActionListener codieren.

Kann mir bitte jemand kurzfristig helfen?

Gruß

Uwe

 

[mihe7]

Du möchtest per Knopfdruck mehrere Komponenten dis-/enablen?

 

[uwe_P]

Guten Morgen.
Korrekt.
Ich habe eine Methode, die Dialogfenster aus dem ActionListener eine "PrüfenButtons" auslöst und einen Boolean zurückgibt.

public static boolean showDialogs(int zahl, String text) {
        boolean b = true;
        ImageIcon icon;
        switch(zahl){
            case 1:
            icon = new ImageIcon("fragezeichen.png");
            int antwort = JOptionPane.showConfirmDialog(null, text, "???", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.INFORMATION_MESSAGE, icon);
        if (antwort == JOptionPane.OK_OPTION) {
            b=true;
            } else if (antwort == JOptionPane.NO_OPTION) {
            b=false;
            } else if (antwort == JOptionPane.CANCEL_OPTION) {
            b=false;
            } else if (antwort == JOptionPane.CLOSED_OPTION) {
            b=false;
            }
            break;
            case 2:
            icon = new ImageIcon("ausrufezeichen.png");
            JOptionPane.showMessageDialog(null, text, "!Achtung!", JOptionPane.INFORMATION_MESSAGE, icon);
            b=true;
            break;
            default:
        }
        return b;
    }

Die Textfelder werden in der Hauptklasse alle so aufgelistet:

tf_newbpd = new JTextField();
tf_newbpd.setVisible(true);
tf_newbpd.setBounds(150,350,200,30);
tf_newbpd.setEnabled(bo_pfad_weiter);

nun hatte ich mir vorgestellt, daß ich im ActionListener nach dem Aufruf des Dialogs den returnwert abgreife und die Variable bo_pfad_weiter änder. Das klappt aber nicht.
:-(

 

[mihe7]

So etwas löst man für gewöhnlich durch Trennung der Darstellung von der Logik mit Hilfe des Observer-Patterns.

Du modellierst den Zustand der View in einer eigenen Klasse (ggf. auch Klassen), das Model, die bei Zustandsänderungen Ereignisse auslöst. Beim Erzeugen der View hast Du Listener, die auf die Zustandsänderung lauschen und daraufhin auf den Komponenten z. B. setEnabled aufrufen.

Der Ablauf ist dann wie folgt: der Dialog ändert das Model, das Model informiert die Listener, die Listener aktualisieren die Komponenten. Je nachdem, wie allgemein Du das halten möchtest, kannst Du entweder eigene Events/Listener haben oder das z. B. über Java Beans Properties lösen.

Hier mal eine etwas allgemeinere Lösung via Properties. Erstmal ein Interface für die Implementierung von Model-Klassen, die über Java Beans Properties verfügen:

import java.beans.PropertyChangeListener;

public interface BeanModel {
    void addPropertyChangeListener(PropertyChangeListener l);
    void addPropertyChangeListener(String propertyName, PropertyChangeListener l);
    void removePropertyChangeListener(PropertyChangeListener l);
    void removePropertyChangeListener(String propertyName, PropertyChangeListener l);
}

Dazu noch eine Convenience-Klasse, damit der immer gleiche Käse nicht immer wieder implementiert werden muss:

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

public abstract class AbstractBeanModel implements BeanModel {
    protected final PropertyChangeSupport pcs = new PropertyChangeSupport(this);

    public void addPropertyChangeListener(PropertyChangeListener l) {
        pcs.addPropertyChangeListener(l);
    }
   
    public void addPropertyChangeListener(String propertyName, PropertyChangeListener l) {
        pcs.addPropertyChangeListener(propertyName, l);
    }
   
    public void removePropertyChangeListener(PropertyChangeListener l) {
        pcs.removePropertyChangeListener(l);
    }
    public void removePropertyChangeListener(String propertyName, PropertyChangeListener l) {
        pcs.removePropertyChangeListener(propertyName, l);
    }
}

Bis dahin ist das ein einmaliges Vorgeplänkel, das nun immer wieder verwendet werden kann. Jetzt geht die eigentliche Arbeit erst los, wir brauchen ein Model für unsere View:

public class MyViewModel extends AbstractModel {
    public static final String ENABLED_PROPERTY = "enabled";
   
    private boolean enabled = true;
   
    public void setEnabled(boolean value) {
        boolean oldValue = enabled;
        enabled = value;
        pcs.firePropertyChange(MyViewModel.ENABLED_PROPERTY, oldValue, enabled);
    }
   
    public boolean isEnabled() {
        return enabled;
    }
}

Objekte dieser Klasse stellen also den (relevanten) Zustand der View dar und lösen bei Zustandsänderungen Ereignisse aus.

Das war es auch schon, man muss es nur noch verwenden. Dazu baue ich mal ein GUI, das aus zwei Fenstern besteht, damit man sieht, dass das auch übergreifend funktioniert. Also, fange ich mal mit der eigentlich View an, die die Elemente enthält, die enabled/disabled werden sollen:

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

public class MyView {
    private final MyViewModel model;

    public MyView(MyViewModel model) {
        this.model = model;
    }

    public void show() {
        JPanel inputs = new JPanel(new GridLayout(3,3));
        for (int i = 0; i < 9; i++) {
            JTextField tf = new JTextField(10);
            inputs.add(tf);

            model.addPropertyChangeListener(MyViewModel.ENABLED_PROPERTY,
                    evt -> tf.setEnabled(model.isEnabled()));
        }
           
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(inputs);
        frame.setSize(800, 600);
        frame.setVisible(true);
    }
}

In Zeile 17/18 wird beim Model nun ein PropertyChangeListener erstellt, der einfach den Wert des Models an die betreffende Komponente weiterleitet.

Jetzt noch ein Fenster, das einen Button enthält, mit dem man umschalten kann:

import javax.swing.*;

public class MyToggler {
    private final MyViewModel model;

    public MyToggler(MyViewModel model) {
        this.model = model;
    }

    public void show() {
        JButton button = new JButton("Toggle");
        button.addActionListener(e -> model.setEnabled(!model.isEnabled()));
           
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        frame.add(button);
        frame.setSize(200, 100);
        frame.setVisible(true);
    }
}

Zum Ausprobieren noch eine Testklasse:

import javax.swing.*;

public class Test {

    public void run() {
        MyViewModel model = new MyViewModel();
        MyView view = new MyView(model);
        MyToggler toggler = new MyToggler(model);
        view.show();
        toggler.show();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Test().run());
    }
}

Fertig. Wenn Du genau hinschaust: MyToggler und MyView sind vollständig entkoppelt - die wissen nichts voneinander, sondern teilen ihr Wissen über ein gemeinsames Model.

 

[uwe_P]

Hey WOW.
Vielen Dank für Deine Mühe, Mühe. Das ist Super. Ich werde es jetz mal kopieren und versuchen zu verstehen.

Hab das zusammenspiel noch nicht ganz verstanden, kommt aber bestimmt, wenn ich es jetzt mal nachbaue und mit den Werten spiele. Ich hoffe, ich darf nochmal Frage, wenn ich was nicht verstanden habe

Vielen Dank!
Gruß

Uwe

 

[mihe7]

Ja, das sieht etwas wild aus, ist aber im Grundsatz ganz einfach. Google mal nach MVC, da findest Du tonnenweise Infos dazu (allerdings wird MVC als Bezeichnung für alle möglichen Zusammenstellungen verwendet; wichtig ist die Trennung von Darstellung und Logik (View und Model) und die Entkopplung über das Observer-Pattern).