eigene event-Klasse, event posten

[wicki]

Hallo,

mein Fernziel: eigene Event-Klasse und Event-Source erzeugen
Im Test will ich ausprobieren, wie man eine Event-Instanz in die EventQueue
reinstellt (also wie man das Event aktiviert). Dazu verwende ich einen
ActionEvent und einen Button. Also wie im normalen Leben, nur dass das Event
nicht durch Button-Click oder die Methode doClick, sondern durch meine
Programmanweisungen erzeugt und aktiviert werden soll.
Wenn der 1. Button gedrückt wird, wird ein Event für den 2. erzeugt und
gepostet.
Ich habe es mit 2 Varianten versucht (siehe Code-Ausschnitt), leider hat keine
Variante funktioniert.

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

class MyClass extends JFrame implements ActionListener {
    JButton bb,bb2;
    public MyClass() {
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        bb = new JButton("Button");
        bb.addActionListener(this);
        bb2= new JButton("Button2");
        bb2.addActionListener(this);
        JPanel p=new JPanel();
        p.add(bb);
        p.add(bb2);
        getContentPane().add(p);
        setSize(200,100);
        setVisible(true);
    }
    public void actionPerformed(ActionEvent ae) {
        System.out.println("Id="+ae.getID()+", "+ae.getActionCommand());
        if (ae.getActionCommand()=="Button") {
          ActionEvent ae2 = new ActionEvent(bb2,1001,"Button2");
          if (false)
          //1.Variante
            bb2.dispatchEvent(ae2);	//ist wahrscheinlch nur der Verteiler
          else {
          //2.Variante
            EventQueue eq = Toolkit.getDefaultToolkit().getSystemEventQueue();
            eq.postEvent(ae2);
          }
          System.out.println("ActionEvent dispatched");
        }
    }
    public static void main(String args[]) {
        new MyClass();
    }
}

Bitte um Hinweise.[/code]

 

[André Uhres]

Versuch's mal mit fireActionPerformed.
Da diese Methode protected ist, kann man sie ohne Weiteres überschreiben
und dann direkt aufrufen:

package layout;
/*
 * Buttonclick.java
 */
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class MyButtonclick extends JFrame {
    private JButton jButton1;
    private MyButton jButton2;
    public MyButtonclick() {
        super("MyButtonclick");
        jButton1 = new JButton();
        jButton2 = new MyButton("jButton2");

        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        getContentPane().setLayout(new FlowLayout());

        jButton1.setText("jButton1");
        jButton1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });
        getContentPane().add(jButton1);

        jButton2.setText("jButton2");
        jButton2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });
        getContentPane().add(jButton2);

        pack();
    }
    
    private void jButton1ActionPerformed(ActionEvent evt) {
        System.out.println("jButton1");
        jButton2.fireActionPerformed(evt);
    }

    private void jButton2ActionPerformed(ActionEvent evt) {
        System.out.println("jButton2");
    }
    public static void main(String args[]) {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                new MyButtonclick().setVisible(true);
            }
        });
    }
    
}
class MyButton extends JButton{
    public MyButton(){
        super();
    }
    public MyButton(String str){
        super(str);
    }
    @Override
    protected void fireActionPerformed(ActionEvent event) {
        super.fireActionPerformed(event);
    }
    
}

 

[wicki]

Dank für die elegante Lösung, die so eine Art "doClick"- Variante darstellt.
Ich habe mir inzwischen überlegt, dass die Nutzung eines "PropertyChangeEvent"
meinen Absichten besser entspricht.

//Ereignisquelle
class PropertyChangeStringBean {
  private String name = "Originalwert";
  //Hilfsklasse zur Ereignisbehandlung
  private PropertyChangeSupport changes = new PropertyChangeSupport( this );

  //Eigenschaft, deren Änderung überwacht wird
  public void setName( String newName ) {
    String oldName = string;
    string = newName;
    changes.firePropertyChange( "otto"      //willkürlicher Name der Eigenschaft
            , oldName, newName );
  }
  public String getName() {
    return name;
  }
  public void addPropertyChangeListener(String propertyName, PropertyChangeListener l ) {
    changes.addPropertyChangeListener( l );
  }
  public void removePropertyChangeListener( PropertyChangeListener l ) {
    changes.removePropertyChangeListener( l );
  }
}

//Listener-Klasse
class MyClass implements PropertyChangeListener {
	.
	.
    PropertyChangeStringBean pb =
        	new PropertyChangeStringBean();    //Quelle des Ereignisses
    pb.addPropertyChangeListener(
                "otto"      //Name der zu überwachenden Eigenschaft
                ,this);     //Listener
	.
	.
    public void propertyChange(PropertyChangeEvent e) {
        System.out.println("Source="+e.getSource() +
                ", "+e.getOldValue() +
                " --> "+e.getNewValue());
    }
	.
	.
}

Wenn nun irgendwer (Listener, Quelle selbst oder ein dritter) die Methode
"setName" der Quelle aufruft, wird ein "PropertyChangeEvent" erzeugt und
per "firePropertyChange" an die registrierten Listener übermittelt.