001/* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2011, by Object Refinery Limited and Contributors.
006 *
007 * Project Info:  http://www.jfree.org/jfreechart/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
022 * USA.
023 *
024 * [Oracle and Java are registered trademarks of Oracle and/or its affiliates. 
025 * Other names may be trademarks of their respective owners.]
026 *
027 * -----------------------
028 * AbstractAnnotation.java
029 * -----------------------
030 * (C) Copyright 2009, by Object Refinery Limited and Contributors.
031 *
032 * Original Author:  Peter Kolb (see patch 2809117);
033 * Contributor(s):   ;
034 *
035 * Changes:
036 * --------
037 * 20-Jun-2009 : Version 1 (PK);
038 *
039 */
040
041package org.jfree.chart.annotations;
042
043import java.io.IOException;
044import java.io.ObjectInputStream;
045import java.io.ObjectOutputStream;
046import java.io.Serializable;
047import java.util.Arrays;
048import java.util.EventListener;
049import java.util.List;
050
051import javax.swing.event.EventListenerList;
052
053import org.jfree.chart.event.AnnotationChangeEvent;
054import org.jfree.chart.event.AnnotationChangeListener;
055
056/**
057 * An abstract implementation of the {@link Annotation} interface, containing a
058 * mechanism for registering change listeners.
059 *
060 * @since 1.0.14
061 */
062public abstract class AbstractAnnotation implements Annotation, Cloneable,
063        Serializable {
064
065    /** Storage for registered change listeners. */
066    private transient EventListenerList listenerList;
067
068    /**
069     * A flag that indicates whether listeners should be notified
070     * about changes of the annotation.
071     */
072    private boolean notify = true;
073
074    /**
075     * Constructs an annotation.
076     */
077    protected AbstractAnnotation() {
078        this.listenerList = new EventListenerList();
079    }
080
081    /**
082     * Registers an object to receive notification of changes to the
083     * annotation.
084     *
085     * @param listener  the object to register.
086     *
087     * @see #removeChangeListener(AnnotationChangeListener)
088     */
089    public void addChangeListener(AnnotationChangeListener listener) {
090        this.listenerList.add(AnnotationChangeListener.class, listener);
091    }
092
093    /**
094     * Deregisters an object so that it no longer receives notification of
095     * changes to the annotation.
096     *
097     * @param listener  the object to deregister.
098     *
099     * @see #addChangeListener(AnnotationChangeListener)
100     */
101    public void removeChangeListener(AnnotationChangeListener listener) {
102        this.listenerList.remove(AnnotationChangeListener.class, listener);
103    }
104
105    /**
106     * Returns <code>true</code> if the specified object is registered with
107     * the annotation as a listener.  Most applications won't need to call this
108     * method, it exists mainly for use by unit testing code.
109     *
110     * @param listener  the listener.
111     *
112     * @return A boolean.
113     *
114     * @see #addChangeListener(AnnotationChangeListener)
115     * @see #removeChangeListener(AnnotationChangeListener)
116     */
117    public boolean hasListener(EventListener listener) {
118        List list = Arrays.asList(this.listenerList.getListenerList());
119        return list.contains(listener);
120    }
121
122    /**
123     * Notifies all registered listeners that the annotation has changed.
124     *
125     * @see #addChangeListener(AnnotationChangeListener)
126     */
127    protected void fireAnnotationChanged() {
128        if (notify) {
129            notifyListeners(new AnnotationChangeEvent(this, this));
130        }
131    }
132
133    /**
134     * Notifies all registered listeners that the annotation has changed.
135     *
136     * @param event  contains information about the event that triggered the
137     *               notification.
138     *
139     * @see #addChangeListener(AnnotationChangeListener)
140     * @see #removeChangeListener(AnnotationChangeListener)
141     */
142    protected void notifyListeners(AnnotationChangeEvent event) {
143
144        Object[] listeners = this.listenerList.getListenerList();
145        for (int i = listeners.length - 2; i >= 0; i -= 2) {
146            if (listeners[i] == AnnotationChangeListener.class) {
147                ((AnnotationChangeListener) listeners[i + 1]).annotationChanged(
148                        event);
149            }
150        }
151
152    }
153
154    /**
155     * Returns a flag that indicates whether listeners should be 
156     * notified about changes to the annotation.
157     *
158     * @return  the flag.
159     *
160     * @see #setNotify(boolean)
161     */
162    public boolean getNotify(){
163        return this.notify;
164    }
165
166    /**
167     * Sets a flag that indicates whether listeners should be notified about
168     * changes of an annotation.
169     *
170     * @param flag  the flag
171     *
172     * @see #getNotify()
173     */
174    public void setNotify(boolean flag){
175        this.notify = flag;
176        if (notify) {
177            fireAnnotationChanged();
178        }
179    }
180
181    /**
182     * Returns a clone of the annotation. The cloned annotation will NOT 
183     * include the {@link AnnotationChangeListener} references that have been
184     * registered with this annotation.
185     *
186     * @return A clone.
187     *
188     * @throws CloneNotSupportedException  if the annotation does not support
189     *                                     cloning.
190     */
191    public Object clone() throws CloneNotSupportedException {
192        AbstractAnnotation clone = (AbstractAnnotation) super.clone();
193        clone.listenerList = new EventListenerList();
194        return clone;
195    }
196
197    /**
198     * Handles serialization.
199     *
200     * @param stream  the output stream.
201     *
202     * @throws IOException if there is an I/O problem.
203     */
204    private void writeObject(ObjectOutputStream stream) throws IOException {
205        stream.defaultWriteObject();
206    }
207
208    /**
209     * Restores a serialized object.
210     *
211     * @param stream  the input stream.
212     *
213     * @throws IOException if there is an I/O problem.
214     * @throws ClassNotFoundException if there is a problem loading a class.
215     */
216    private void readObject(ObjectInputStream stream)
217        throws IOException, ClassNotFoundException {
218        stream.defaultReadObject();
219        this.listenerList = new EventListenerList();
220    }
221
222}