Event dispatching to swing components

Question

Hi,
I'm implementing an extension of JTextPane, and I would like to make it as much reusable as possible.
In order to do this, the class don't have to know about the external world (components)..
The class should notify events (e.g. an event could be that a specific string has been typed..) to the other components just sending a message (or event), and all the components registered to that specific event implement their behavior to react to it.. quite simple..
which is the simplest solution in Java to do this?
thanks in advance..

Answer 1

You should implement event dispatching based on the listener model, for consistency. Since you are extending JTextPane, a lot of the event dispatching code is written for you. Look up JTextPane in the javadocs and check out all the classes it is derived from. To take advantage of the already written listener code, simply call the appropriate fireWhateverEvent method whenever something happens. That will cause the event to be dispatched to all listeners registered with that component. If you want to define some new events that aren't covered by any of the listener methods in any of the classes your new class is derived from, here's the general way to do it:
1) Define a new listener interface that implements the EventListener interface (which contains no methods).
2) In your new listener interface, include methods for specific events, such as keyPressed, actionPerformed, textTyped, etc...
3) Each of these methods should take a single parameter describing the event. This parameter should be a class that extends EventObject and that contains data relevant to your event. For example, you may define a TextEvent class that extends EventObject. The only methods EventObject has is getSource() and toString(). You won't really need to override these as long as you call the EventObject(Object) constructor from your TextEvent constructors.
4) In your JTextPane derived class, define methods that can add, remove, and get a list of all registered event listeners for your event (ex: void addTextListener(TextListener t), void removeTextListener(TextListener t), TextListener[] getTextListeners()).
5) add*Listener should add the listener to an internal list of listeners (a LinkedList or a Vector are good ways to store the registered listener lists). remove*Listener should remove the listener from the list, and get*Listeners should return the list in array form.
6) For ease-of-use, define a fire method like fireTextListener(params), which creates a new TextEvent (assuming you're doing the TextListener thing) holding the specified event data and iterates through the internal list of listeners, calling the appropriate method in each one and passing your TextEvent to it.
7) Call your fire*Event functions wherever appropriate to fire events.
It's simpler than it sounds. Here's a small example:
// TextListener.java
public class TextListener implements EventListener {
    public void textInserted (TextEvent e);
    public void textDeleted  (TextEvent e);
// TextEvent.java
public class TextEvent extends EventObject {
    protected int    pos0;
    protected int    pos1;
    protected String text;
    public TextEvent (Object source, int pos0, int pos1, String text) {
        super(source);
        this.pos0 = pos0;
        this.pos1 = pos1;
        this.text = (text != null) ? text : "";
    public TextEvent (Object source, int pos0, int pos1) {
        this(source, pos0, pos1, null);
    public int getPos0 () {
        return pos0;
    public int getPos1 () {
        return pos1;
    public String getText () {
        return text;
// MyTextPane.java
public class MyTextPane extends JTextPane {
    LinkedList textListeners = new LinkedList();
    // This is just some method you defined, can be anything.
    public void someMethodThatInsertsText () {
        fireTextInserted(pos0, pos1, textInserted);
    // Same with this, this can be anything.
    public void someOtherMethodThatDeletesText () {
        fireTextDeleted(pos0, pos1);
    public void addTextListener (TextListener t) {
        textListeners.add(t);
    public void removeTextListener (TextListener t) {
        textListeners.remove(t);
    public TextListener[] getTextListeners () {
        TextListener ts = new TextListener[textListeners.size()];
        Iterator     i;
        int          j;
        // Don't think toArray works good because I'm 99% sure you'll
        // have trouble casting an Object[] to a TextListener[].
        for (j = 0, i = textListeners.iterator(); i.hasNext(); j ++)
            ts[j] = (TextListener)i.next();
    protected fireTextInserted (int pos0, int pos1, String text) {
        TextEvent e = new TextEvent(this, pos0, pos1, text);
        Iterator  i = textListeners.iterator();
        while (i.hasNext())
            ((TextListener)i.next()).textInserted(e);
    protected void fireTextDeleted (int pos0, int pos1) {
        TextEvent e = new TextEvent(this, pos0, pos1);
        Iterator  i = textListeners.iterator();
        while (i.hasNext())
            ((TextListener)i.next()).textDeleted(e);
};There. I just typed that there, didn't test or compile it, but you get the gist of it. Then, like you do with any listener stuff, when you want to set up a listener and register it with a MyTextPane instance, just create some class that extends TextListener and overrides textInserted and textDeleted to do whatever your application needs to do.
Hope that makes sense.
Jason