Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.mapcontext.events.listeners;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.mapcontext.events.AtomicEvent;

import org.gvsig.fmap.mapcontext.events.ColorEvent;

import org.gvsig.fmap.mapcontext.events.ExtentEvent;

import org.gvsig.fmap.mapcontext.events.FMapEvent;

import org.gvsig.fmap.mapcontext.events.ProjectionEvent;

import org.gvsig.fmap.mapcontext.layers.CancelationException;

import org.gvsig.fmap.mapcontext.layers.LayerCollectionEvent;

import org.gvsig.fmap.mapcontext.layers.LayerCollectionListener;

import org.gvsig.fmap.mapcontext.layers.LayerEvent;

import org.gvsig.fmap.mapcontext.layers.LayerListener;

import org.gvsig.fmap.mapcontext.layers.LayerPositionEvent;

import org.gvsig.fmap.mapcontext.layers.SelectionEvent;

import org.gvsig.fmap.mapcontext.layers.SelectionListener;

import org.gvsig.fmap.mapcontext.rendering.legend.events.LegendChangedEvent;

import org.gvsig.fmap.mapcontext.rendering.legend.events.listeners.LegendListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * <code>EventBuffer</code> represents a buffer of events that allows store

 * listeners of events produced in layers of a <code>MapContext</code> instance,

 * and configure its dispatching mode.

 *

 * The <i>dispatching mode</i>:

 * <ul>

 * <li><code>true</code> : dispatches each new event received.</li>

 * <li><code>false</code> : accumulates all new events received in a internal

 * buffer, and only will dispatch them (according to the order they were

 * received) when changes the mode.</li>

 * </ul>

 *

 * @see LegendListener

 * @see LayerCollectionListener

 * @see SelectionListener

 * @see ViewPortListener

 * @see LegendListener

 *

 * @author gvSIG Team

 */

public class EventBuffer implements LegendListener, LayerCollectionListener,

        SelectionListener, ViewPortListenerEx1, LayerListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(EventBuffer.class);

    /**

     * List with all events received and don't dispatched.

     *

     * @see #endAtomicEvent()

     * @see #legendChanged(LegendChangedEvent)

     * @see #layerAdded(LayerCollectionEvent)

     * @see #layerMoved(LayerPositionEvent)

     * @see #layerRemoved(LayerCollectionEvent)

     * @see #layerAdding(LayerCollectionEvent)

     * @see #layerMoving(LayerPositionEvent)

     * @see #layerRemoving(LayerCollectionEvent)

     * @see #visibilityChanged(LayerCollectionEvent)

     * @see #visibilityChanged(LayerEvent)

     * @see #selectionChanged(SelectionEvent)

     * @see #extentChanged(ExtentEvent)

     * @see #activationChanged(LayerEvent)

     * @see #nameChanged(LayerEvent)

     * @see #backColorChanged(ColorEvent)

     * @see #editionChanged(LayerEvent)

     * @see #projectionChanged(ProjectionEvent)

     * @see #fireAtomicEventListener

     */

    private final List<FMapEvent> events = new ArrayList();

    /**

     * List with all listeners registered.

     *

     * @see #addAtomicEventListener(AtomicEventListener)

     * @see #removeAtomicEventListener(AtomicEventListener)

     */

    private final List<AtomicEventListener> listeners = new ArrayList();

    /**

     * Allows enable or disable the <i>dispatching mode</i>.

     *

     * @see #beginAtomicEvent()

     * @see #endAtomicEvent()

     */

    private boolean dispatching = true;

    /**

     * Enables buffer in <i>accumulation event</i> mode.

     *

     * All new events received, will be accumulated and won't notified to their

     * respective listeners, until this buffer would received a call to

     * {@link #endAtomicEvent() endAtomicEvent}.

     *

     * @see #endAtomicEvent()

     */

    public void beginAtomicEvent() {

        dispatching = false;

    }

    /**

     * Disables buffer in <i>accumulation event</i> mode.

     *

     * All events accumulated will be notify to their respective listeners, in

     * the same order as they arrived.

     *

     * @see #beginAtomicEvent()

     */

    public void endAtomicEvent() {

        fireAtomicEventListener();

        events.clear();

        dispatching = true;

    }

    @Override

    public void legendChanged(LegendChangedEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void layerAdded(LayerCollectionEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void layerMoved(LayerPositionEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void layerRemoved(LayerCollectionEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void layerAdding(LayerCollectionEvent e) throws CancelationException {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void layerMoving(LayerPositionEvent e) throws CancelationException {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void layerRemoving(LayerCollectionEvent e) throws CancelationException {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void visibilityChanged(LayerCollectionEvent e) throws CancelationException {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void selectionChanged(SelectionEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void extentChanged(ExtentEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    /**

     * Appends, if wasn't, the specified listener to the end of the internal

     * list of atomic event listeners.

     *

     * @param listener an object that implements the atomic event listener

     *

     * @return <code>true</code> if has added the listener successfully;

     * otherwise <code>false</code>

     *

     * @see #removeAtomicEventListener(AtomicEventListener)

     * @see #fireAtomicEventListener()

     */

    public boolean addAtomicEventListener(AtomicEventListener listener) {

        boolean bFound = false;

        for (int i = 0; i < listeners.size(); i++) {

            if (listeners.get(i) == listener) {

                bFound = true;

            }

        }

        if (!bFound) {

            listeners.add(listener);

        }

        return true;

    }

    /**

     * <p>

     * Removes a single instance of the

     * {@link AtomicEventListener AtomicEventListener} from the internal list,

     * if it is present (optional operation).Returns <tt>true</tt>

 if the list contained the specified element (or equivalently, if the list

 changed as a result of the call)

 .<p>

     *

     * @param listener, element to be removed from this list, if present

     * @return <tt>true</tt> if the list contained the specified element

     *

     * @see #addAtomicEventListener(AtomicEventListener)

     * @see #fireAtomicEventListener()

     */

    public boolean removeAtomicEventListener(AtomicEventListener listener) {

        return listeners.remove(listener);

    }

    /**

     * Executes the {@linkplain AtomicEventListener#atomicEvent(AtomicEvent)}

     * method of all listeners registered.

     *

     * @see #addAtomicEventListener(AtomicEventListener)

     * @see #removeAtomicEventListener(AtomicEventListener)

     */

    private void fireAtomicEventListener() {

        if (events.isEmpty()) {

            return; // No hay eventos que lanzar.

        }

        for (Iterator i = listeners.iterator(); i.hasNext();) {

            AtomicEventListener listener = (AtomicEventListener) i.next();

            if( listener==null ) {

                continue;

            }

            AtomicEvent e = new AtomicEvent(events);

            try {

                listener.atomicEvent(e);

            } catch(Exception ex) {

                LOGGER.warn("Problems calling listener ("+listener.getClass().getName()+").", ex);

            }

        }

        events.clear();

    }

    @Override

    public void visibilityChanged(LayerEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void activationChanged(LayerEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void nameChanged(LayerEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void backColorChanged(ColorEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void selectionColorChanged(ColorEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void editionChanged(LayerEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void projectionChanged(ProjectionEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

    @Override

    public void drawValueChanged(LayerEvent e) {

        events.add(e);

        if (dispatching) {

            fireAtomicEventListener();

        }

    }

}