Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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 2

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.cit.gvsig.fmap;

import java.awt.Graphics2D;

import java.awt.RenderingHints;

import java.awt.Toolkit;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.util.ArrayList;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.geo.Projected;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.layers.CancelationException;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.GraphicLayer;

import com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent;

import com.iver.cit.gvsig.fmap.layers.LayerCollectionListener;

import com.iver.cit.gvsig.fmap.layers.LayerDrawEvent;

import com.iver.cit.gvsig.fmap.layers.LayerDrawingListener;

import com.iver.cit.gvsig.fmap.layers.LayerPositionEvent;

import com.iver.cit.gvsig.fmap.layers.LegendListener;

import com.iver.cit.gvsig.fmap.layers.VectorialAdapter;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.fmap.layers.layerOperations.Classifiable;

import com.iver.cit.gvsig.fmap.layers.layerOperations.Selectable;

import com.iver.cit.gvsig.fmap.operations.selection.Record;

import com.iver.cit.gvsig.fmap.operations.strategies.FeatureVisitor;

import com.iver.cit.gvsig.fmap.operations.strategies.SelectedZoomVisitor;

import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;

import com.iver.cit.gvsig.fmap.rendering.styling.FStyle2D;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.swing.threads.Cancellable;

/**

 * Modelo del mapa.

 *

 * @author Fernando Gonz?lez Cort?s

 */

public class FMap implements Projected {

        public static final double[] CHANGEM = { 1000, 1, 0.01, 0.001, 1609.344,

                        0.9144, 0.3048, 0.0254 };

        public static final double[] CHANGE = { 100000, 100, 1, 0.1, 160934.4,

                        91.44, 30.48, 2.54 };

        public static final int EQUALS = 0;

        public static final int DISJOINT = 1;

        public static final int INTERSECTS = 2;

        public static final int TOUCHES = 3;

        public static final int CROSSES = 4;

        public static final int WITHIN = 5;

        public static final int CONTAINS = 6;

        public static final int OVERLAPS = 7;

        private FLayers layers = new FLayers(this, null);

        private GraphicLayer tracLayer = new GraphicLayer();

        private ViewPort viewPort;

        // private ArrayList invalidationListeners = new ArrayList();

        private ArrayList legendListeners = new ArrayList();

        private ArrayList layerDrawingListeners = new ArrayList();

        private EventBuffer eventBuffer = new EventBuffer();

        private LayerEventListener layerEventListener = null;

        private ArrayList layersError = new ArrayList();

        private ArrayList errorListeners = new ArrayList();

        // public static ResourceBundle myResourceBundle =

        // ResourceBundle.getBundle("FMap");

        /**

         * Crea un nuevo FMap.

         *

         * @param vp

         *            ViewPort.

         */

        public FMap(ViewPort vp) {

                this.viewPort = vp;

                layerEventListener = new LayerEventListener();

                layers.addLayerCollectionListener(layerEventListener);

                layers.addLayerCollectionListener(eventBuffer);

                if (viewPort != null) {

                        viewPort.addViewPortListener(eventBuffer);

                }

        }

        /**

         * A?ade un LegendListener.

         *

         * @param listener

         *            LegendListener a a?adir.

         */

        public void addLayerListener(LegendListener listener) {

                legendListeners.add(listener);

        }

        public void addLayerDrawingListener(LayerDrawingListener listener) {

                layerDrawingListeners.add(listener);

        }

        public void removeLayerDrawListener(LayerDrawingListener listener) {

                layerDrawingListeners.remove(listener);

        }

        public void addErrorListener(ErrorListener listener) {

                errorListeners.add(listener);

        }

        public void removeErrorListener(LegendListener listener) {

                legendListeners.remove(listener);

        }

        /**

         * M?todo ejecutado cuando hay un cambio de leyenda que se quiera reflejar.

         *

         * @param e

         *            LegendChangedEvent.

         */

        public synchronized void callLegendChanged() {

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

                        ((LegendListener) legendListeners.get(i)).legendChanged(null);

                }

                // getLayers().moveTo(0,0);

        }

        public synchronized void fireLayerDrawingEvent(LayerDrawEvent e) {

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

                {

                        LayerDrawingListener listener = (LayerDrawingListener) layerDrawingListeners.get(i);

                        switch (e.getEventType())

                        {

                                case LayerDrawEvent.LAYER_BEFORE_DRAW:

                                        listener.beforeLayerDraw(e);

                                        break;

                                case LayerDrawEvent.LAYER_AFTER_DRAW:

                                        listener.afterLayerDraw(e);

                                        break;

                                case LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW:

                                        listener.beforeGraphicLayerDraw(e);

                                        break;

                                case LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW:

                                        listener.afterLayerGraphicDraw(e);

                                        break;

                        }

                }

                // getLayers().moveTo(0,0);

        }

        public synchronized void callNewErrorEvent(ErrorEvent e) {

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

                        ((ErrorListener) errorListeners.get(i)).errorThrown(e);

                }

                // getLayers().moveTo(0,0);

        }

        /**

         * Borra un LegendListener.

         *

         * @param listener

         *            LegendListener a borrar.

         */

        public void removeLayerListener(LegendListener listener) {

                legendListeners.remove(listener);

        }

        /**

         * Devuelve las capas que contiene el mapa.

         *

         * @return Capas.

         */

        public FLayers getLayers() {

                return layers;

        }

        /**

         * Dibuja en la imagen que se pasa como par?metro el contenido de las capas

         * visibles del mapa y teniendo en cuenta los datos del ViewPort contenido

         * en este FMap

         *

         * @param b

         *            Imagen.

         */

        public void drawLabels(BufferedImage b) {

        }

        /**

         * M?todo de conveniencia que se usa provisionalmente para solicitar un

         * refresco de todo lo que dependa del FMap (MapContext). Esto provocar? un

         * evento de cambio de orden de capas que obligar? a redibujar todo lo que

         * depende de FMap (TOC, MapControl, FFrameView, etc).

         */

        public void invalidate() {

                getLayers().moveTo(0, 0);

        }

        /**

         * Imprime el las capas que contiene el FMap sobre el Graphics2D que se pasa

         * como par?metro, normalmente es el Graphics de la impresora.

         *

         * @param g

         *            Graphics2D

         *

         * @throws DriverException

         */

        public void print(Graphics2D g, double scale) throws DriverException {

                RenderingHints renderHints = new RenderingHints(

                                RenderingHints.KEY_ANTIALIASING,

                                RenderingHints.VALUE_ANTIALIAS_ON);

                renderHints.put(RenderingHints.KEY_RENDERING,

                                RenderingHints.VALUE_RENDER_QUALITY);

                g.setRenderingHints(renderHints);

                Cancellable cancel = new Cancellable() {

                        public boolean isCanceled() {

                                return false;

                        }

                        public void setCanceled(boolean canceled) {

                                // No queremos que se pueda cancelar la impresi?n.

                        }

                };

                layers.print(g, viewPort, cancel, scale);

                tracLayer.draw(null, g, viewPort, cancel, scale);

        }

        /**

         * Crea un nuevo FMap con la informaci?n del ViewPort que se pasa como

         * par?metro.

         *

         * @param vp

         *            ViewPort.

         *

         * @return FMap nuevo.

         */

        public FMap createNewFMap(ViewPort vp) {

                FMap ret = new FMap(vp);

                ret.layers = this.layers;

                return ret;

        }

        /**

         * Crea un nuevo FMap totalmente desligado, se replican las capas y el

         * ViewPort

         *

         * @return FMap clonado.

         *

         * @throws XMLException

         */

        public FMap cloneFMap() throws XMLException {

                return createFromXML(getXMLEntity());

        }

        /**

         * A?ade la capa que se pasa como par?metro al nodo que se pasa como

         * parametro y lanza ProjectionMismatchException si no est?n todas las capas

         * de este FMap en la misma proyecci?n. Lanza un ChildNotAllowedException si

         * la capa no es un FLayers y no permite hijos

         *

         * @param vectorial

         *            DOCUMENT ME!

         */

        /*

         * public void addLayer(LayerPath parent, FLayer layer) throws

         * ProjectionMismatchException, ChildrenNotAllowedException {

         * layers.addLayer(parent, layer); } public void removeLayer(LayerPath

         * parent)throws ChildrenNotAllowedException{ layers.removeLayer(parent); }

         */

        /**

         * A?ade una capa al grupo de capas que se sit?a por encima de todas las

         * otras capas

         *

         * @param vectorial

         *            FLayer.

         */

        public void addToTrackLayer(FLayer vectorial) {

        }

        /**

         * Devuelve la escala de la vista en pantalla.

         *

         * @return escala de la vista.

         */

        public long getScaleView() {

                // TODO falta implementar un di?logo para poder especificar el usuario

                // los pixels exactos de su pantalla.

                Toolkit kit = Toolkit.getDefaultToolkit();

                double dpi = kit.getScreenResolution();

                IProjection proj = viewPort.getProjection();

                if (viewPort.getImageSize() == null)

                        return -1;

                double w = ((viewPort.getImageSize().getWidth() / dpi) * 2.54);

                if (viewPort.getAdjustedExtent() == null) {

                        return 0;

                }

                if (proj == null) {

                        return (long) (viewPort.getAdjustedExtent().getWidth() / w * CHANGE[getViewPort()

                                        .getMapUnits()]);

                }

                return (long) proj.getScale(viewPort.getAdjustedExtent().getMinX(),

                                viewPort.getAdjustedExtent().getMaxX(), viewPort.getImageSize()

                                                .getWidth(), dpi);

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#setVectorial(com.iver.cit.gvsig.fmap.VectorialAdapter)

         */

        public void setVectorial(VectorialAdapter v) {

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#process(com.iver.cit.gvsig.fmap.FeatureSelectorVisitor)

         */

        public void process(FeatureVisitor visitor) {

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#processSelected(com.iver.cit.gvsig.fmap.FeatureVisitor)

         */

        public void processSelected(FeatureVisitor visitor) {

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#select(com.iver.cit.gvsig.fmap.FeatureSelectorVisitor,

         *      VectorialSubSet)

         */

        public void select(FeatureVisitor visitor) {

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#selectFromSelection()

         */

        public void selectFromSelection() {

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#createIndex()

         */

        public void createIndex() {

        }

        /**

         * @see org.cresques.geo.Projected#getProjection()

         */

        public IProjection getProjection() {

                return getViewPort().getProjection();

        }

        /**

         * Inserta la proyecci?n.

         *

         * @param proj

         *            Proyecci?n.

         */

        public void setProjection(IProjection proj) {

                if (getViewPort() != null) {

                        getViewPort().setProjection(proj);

                }

        }

        /**

         * @see org.cresques.geo.Projected#reProject(org.cresques.cts.ICoordTrans)

         */

        public void reProject(ICoordTrans arg0) {

                // TODO implementar reprojecci?n (lo que sea eso)

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#selectByPoint(java.awt.geom.Point2D,

         *      double)

         */

        /*

         * public void selectByPoint(Point2D p, double tolerance) throws

         * DriverException { Point2D mapPoint = viewPort.toMapPoint((int) p.getX(),

         * (int) p.getY()); SelectByPointVisitor visitor = new

         * SelectByPointVisitor(); visitor.setQueriedPoint(mapPoint);

         * visitor.setTolerance(getViewPort().toMapDistance(3));

         *

         * try { layers.process(visitor); } catch (VisitException e) { throw new

         * RuntimeException("No se espera que SelectByPointVisitor lance esta

         * excepci?n", e); } }

         */

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#selectByRect(java.awt.geom.Rectangle2D)

         */

        /*

         * public void selectByRect(Rectangle2D rect) throws DriverException {

         * FLayer[] actives = layers.getActives(); for (int i=0; i < actives.length;

         * i++) { if (actives[i] instanceof FLyrVect) { FLyrVect lyrVect =

         * (FLyrVect) actives[i]; FBitSet oldBitSet = lyrVect.getSelection();

         * FBitSet newBitSet = lyrVect.queryByRect(rect); newBitSet.xor(oldBitSet);

         * lyrVect.setSelection(newBitSet); } }

         *  }

         */

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#selectByShape(com.iver.cit.gvsig.fmap.fshape.IGeometry,

         *      int)

         */

        public void selectByShape(IGeometry g, int relationship) {

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#queryByPoint(Point2D,

         *      double)

         */

        public Record[] queryByPoint(Point2D p, double tolerance) {

                return null;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#queryByRect(java.awt.geom.Rectangle2D)

         */

        public Record[] queryByRect(Rectangle2D rect) {

                return null;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#queryByShape(com.iver.cit.gvsig.fmap.fshape.IGeometry,

         *      int)

         */

        public Record[] queryByShape(IGeometry g, int relationship) {

                return null;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.strategies.Strategy#getSelectionBounds()

         */

        public Rectangle2D getSelectionBounds() {

                SelectedZoomVisitor visitor = new SelectedZoomVisitor();

                try {

                        layers.process(visitor);

                } catch (DriverException e1) {

                        throw new RuntimeException(

                                        "No se espera que SelectByPointVisitor lance esta excepci?n",

                                        e1);

                } catch (VisitException e) {

                        throw new RuntimeException(

                                        "No se espera que SelectByPointVisitor lance esta excepci?n",

                                        e);

                }

                return visitor.getSelectBound();

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.LayerOperations#draw(java.awt.image.BufferedImage,

         *      java.awt.Graphics2D, FStyle2D)

         */

        public void draw(BufferedImage image, Graphics2D g, Cancellable cancel,

                        double scale) throws DriverException {

                if (viewPort.getExtent() == null) {

                        // System.err.println("viewPort.getExtent() = null");

                        return;

                }

                System.out.println("Viewport despues: " + viewPort.toString());

                /*

                 * if ((viewPort.getImageWidth() <=0) || (viewPort.getImageHeight() <=

                 * 0)) { return; }

                 */

                prepareDrawing(image, g, scale);

                // M?s c?lidad al texto

                RenderingHints renderHints = new RenderingHints(

                                RenderingHints.KEY_ANTIALIASING,

                                RenderingHints.VALUE_ANTIALIAS_ON);

                renderHints.put(RenderingHints.KEY_RENDERING,

                                RenderingHints.VALUE_RENDER_QUALITY);

                renderHints.put(RenderingHints.KEY_TEXT_ANTIALIASING,

                                RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

                g.setRenderingHints(renderHints);

                long t1 = System.currentTimeMillis();

                layers.draw(image, g, viewPort, cancel, scale);

                LayerDrawEvent beforeTracLayerEvent = new LayerDrawEvent(tracLayer,

                                g, viewPort, LayerDrawEvent.GRAPHICLAYER_BEFORE_DRAW);

                fireLayerDrawingEvent(beforeTracLayerEvent);

                tracLayer.draw(image, g, viewPort, cancel, scale);

                LayerDrawEvent afterTracLayerEvent = new LayerDrawEvent(tracLayer,

                                g, viewPort, LayerDrawEvent.GRAPHICLAYER_AFTER_DRAW);

                fireLayerDrawingEvent(afterTracLayerEvent);

                long t2 = System.currentTimeMillis();

                System.err.println("Tiempo de dibujado:" + (t2 - t1) +

                                " mseg. Memoria libre:" + Runtime.getRuntime().freeMemory() / 1024  + " KB");

                /*

                 * g.setColor(Color.BLUE); GeneralPath shpR = new

                 * GeneralPath(viewPort.getExtent());

                 * shpR.transform(viewPort.getAffineTransform()); g.draw(shpR);

                 */

                System.gc();

        }

        /**

         * En esta funci?n vamos a revisar las capas que necesitan repintarse,

         * por si hay alguna que se haya guardado la imagen de las anteriores

         * y puede acelerar el dibujado.

         * @param image

         * @param g

         * @param scale

         */

        private void prepareDrawing(BufferedImage image, Graphics2D g, double scale) {

                // Primera pasada: si alguna capa necesita repintarse por debajo

                // de la que tiene la cache, TODAS necesitan

                // ser repintadas.

                boolean bNeedRepaint = false;

                boolean bMayExistAceleration = false;

                for (int i = 0; i < layers.getLayersCount(); i++)

                {

                        FLayer lyr = layers.getLayer(i);

                        if (lyr.isCachingDrawnLayers() && (lyr.getCacheImageDrawnLayers() != null))

                        {

                                bMayExistAceleration = true;

                        }

                        else

                        {

                                if (lyr.isDirty())

                                        bNeedRepaint = true;

                        }

                }

                if (bMayExistAceleration==false)

                        bNeedRepaint = true;

                if (bNeedRepaint)

                        layers.setDirty(true);

                else

                        recursivePrepareDrawing(layers, 0);

        }

        private void validatePreviousLayers(FLayers layers, int index)

        {

                // TODO: Aqu? quiz?s habr?a que explorar los padres de las capas

                // para marcar y/o asignar la imagen cacheada.

                for (int i = 0; i < index; i++)

                {

                        FLayer lyr = layers.getLayer(i);

                        lyr.setDirty(false);

                }

                // Las de arriba las marcamos como sucias

//                for (int i = index; i < layers.getLayersCount(); i++)

//                {

//                        FLayer lyr = layers.getLayer(i);

//                        lyr.setDirty(true);

//                }

        }

        private void recursivePrepareDrawing(FLayers parent, int indexInParent)

        {

                for (int i = indexInParent; i < parent.getLayersCount(); i++)

                {

                        FLayer lyr = layers.getLayer(i);

                        if (lyr.isCachingDrawnLayers() && (lyr.getCacheImageDrawnLayers() != null))

                        {

                                // les decimos a las anteriores que est?n validadas (not dirty)

                                // para que no se dibujen.

                                if (lyr.isDirty())

                                        validatePreviousLayers(parent, i);

                        }

                        if (lyr instanceof FLayers)

                        {

                                recursivePrepareDrawing((FLayers)lyr, 0);

                        }

                }

        }

        public void drawGraphics(BufferedImage image, Graphics2D g,

                        Cancellable cancel, double scale) throws DriverException {

                if (viewPort == null)

                        return;

                tracLayer.draw(image, g, viewPort, cancel, scale);

        }

        /**

         * @see com.iver.cit.gvsig.fmap.operations.LayerOperations#draw(java.awt.image.BufferedImage,

         *      java.awt.Graphics2D, FStyle2D)

         */

        public void draw(BufferedImage image, Graphics2D g, double scale)

                        throws DriverException {

                layers.setDirty(true);

                draw(image, g, new Cancellable() {

                        /**

                         * @see com.iver.utiles.swing.threads.Cancellable#isCanceled()

                         */

                        public boolean isCanceled() {

                                return false;

                        }

                        public void setCanceled(boolean canceled) {

                                // TODO Auto-generated method stub

                        }

                }, scale);

        }

        /**

         * Devuelve el ViewPort.

         *

         * @return Returns the viewPort.

         */

        public ViewPort getViewPort() {

                return viewPort;

        }

        /**

         * Inserta un ViewPort.

         *

         * @param viewPort

         *            The viewPort to set.

         */

        public void setViewPort(ViewPort viewPort) {

                if (this.viewPort != null) {

                        this.viewPort.removeViewPortListener(eventBuffer);

                }

                this.viewPort = viewPort;

                viewPort.addViewPortListener(eventBuffer);

        }

        /**

         * M?todo de conveniencia. Recorre las capas y te da el fullExtent

         *

         * @return fullExtent de todas las capas.

         *

         * @throws DriverException

         */

        public Rectangle2D getFullExtent() throws DriverException {

                return layers.getFullExtent();

        }

        /**

         * Devuelve el XMLEntity.

         *

         * @return XMLEntity.

         * @throws XMLException

         */

        public XMLEntity getXMLEntity() throws XMLException {

                XMLEntity xml = new XMLEntity();

                xml.putProperty("className", this.getClass().getName());

                xml.addChild(viewPort.getXMLEntity());

                xml.addChild(layers.getXMLEntity());

                return xml;

        }

        /**

         * Crea un nuevo FMAp a partir del XMLEntity.

         *

         * @param xml

         *            XMLEntity

         *

         * @return Nuevo FMap.

         *

         * @throws XMLException

         */

        public static FMap createFromXML03(XMLEntity xml) throws XMLException {

                ViewPort vp = ViewPort.createFromXML03(xml.getChild(0));

                FMap fmap = new FMap(vp);

                fmap.layers.setXMLEntity03(xml.getChild(1));

                return fmap;

        }

        /**

         * Crea un nuevo FMAp a partir del XMLEntity.

         *

         * @param xml

         *            XMLEntity

         *

         * @return Nuevo FMap.

         *

         * @throws XMLException

         */

        public static FMap createFromXML(XMLEntity xml) throws XMLException {

                ViewPort vp = ViewPort.createFromXML(xml.getChild(0));

                FMap fmap = new FMap(vp);

                fmap.layers.setXMLEntity(xml.getChild(1));

                return fmap;

        }

        /**

         * A?ade un AtomicEventListener.

         *

         * @param listener

         *            AtomicEventListener.

         *

         * @return True si se ha a?adido correctamente.

         */

        public boolean addAtomicEventListener(AtomicEventListener listener) {

                return eventBuffer.addAtomicEventListener(listener);

        }

        /**

         * Borra un AtomicEventListener de la lista de listeners.

         *

         * @param listener

         *            AtomicEventListener a borrar.

         *

         * @return True si se ha borrado correctamente.

         */

        public boolean removeAtomicEventListener(AtomicEventListener listener) {

                return eventBuffer.removeAtomicEventListener(listener);

        }

        /**

         * Inicializa los AtomicEvent.

         */

        public void beginAtomicEvent() {

                eventBuffer.beginAtomicEvent();

        }

        /**

         * Finaliza los AtomicEvent.

         */

        public void endAtomicEvent() {

                eventBuffer.endAtomicEvent();

        }

        /**

         * Evento Layer.

         *

         * @author Fernando Gonz?lez Cort?s

         */

        public class LayerEventListener implements LayerCollectionListener {

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerAdded(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

                 */

                public void layerAdded(LayerCollectionEvent e) {

                        // Si es la primera capa, fijamos su extent al ViewPort

                        // if (getLayers().getLayersCount() == 1) {

                        if (getViewPort().getExtent() == null) {

                                FLayer lyr = e.getAffectedLayer();

                                try {

                                        getViewPort().setExtent(lyr.getFullExtent());

                                } catch (DriverException e1) {

                                }

                        }

                        // Registramos al FMap como listener del legend de las capas

                        FLayer lyr = e.getAffectedLayer();

                        lyr.addLayerListener(eventBuffer);

                        if (lyr instanceof Classifiable) {

                                Classifiable c = (Classifiable) lyr;

                                c.addLegendListener(eventBuffer);

                        }

                        if (lyr instanceof AlphanumericData) {

                                Selectable s=null;

                                try {

                                        s = ((AlphanumericData) lyr).getRecordset();

                                } catch (DriverException e1) {

                                        // TODO Auto-generated catch block

                                        e1.printStackTrace();

                                }

                                s.addSelectionListener(eventBuffer);

                        }

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerMoved(com.iver.cit.gvsig.fmap.layers.LayerPositionEvent)

                 */

                public void layerMoved(LayerPositionEvent e) {

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerRemoved(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

                 */

                public void layerRemoved(LayerCollectionEvent e) {

                        FLayer lyr = e.getAffectedLayer();

                        lyr.removeLayerListener(eventBuffer);

                        if (lyr instanceof Classifiable) {

                                Classifiable c = (Classifiable) lyr;

                                c.removeLegendListener(eventBuffer);

                        }

                        if (lyr instanceof Selectable) {

                                Selectable s = (Selectable) lyr;

                                s.addSelectionListener(eventBuffer);

                        }

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerAdding(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

                 */

                public void layerAdding(LayerCollectionEvent e)

                                throws CancelationException {

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerMoving(com.iver.cit.gvsig.fmap.layers.LayerPositionEvent)

                 */

                public void layerMoving(LayerPositionEvent e)

                                throws CancelationException {

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#layerRemoving(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

                 */

                public void layerRemoving(LayerCollectionEvent e)

                                throws CancelationException {

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#activationChanged(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

                 */

                public void activationChanged(LayerCollectionEvent e)

                                throws CancelationException {

                }

                /**

                 * @see com.iver.cit.gvsig.fmap.layers.LayerCollectionListener#visibilityChanged(com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent)

                 */

                public void visibilityChanged(LayerCollectionEvent e)

                                throws CancelationException {

                }

        }

        public void addAsCollectionListener(FLayers layers2) {

                layers2.addLayerCollectionListener(layerEventListener);

        }

        public GraphicLayer getGraphicsLayer() {

                return tracLayer;

        }

        /**

         * Asigna la capa gr?fica

         * @param graphicLayer

         */

        public void setGraphicsLayer(GraphicLayer graphicLayer) {

                tracLayer = graphicLayer;

        }

        public boolean equals(Object arg0) {

                FMap map = (FMap) arg0;

                if (super.equals(arg0))

                        return true;

                if (getLayers() == map.getLayers())

                        return true;

                boolean isEqual = true;

                if (map.getLayers().getLayersCount() == getLayers().getLayersCount()) {

                        for (int i = 0; i < getLayers().getLayersCount(); i++) {

                                if (!getLayers().getLayer(i).getName().equals(

                                                map.getLayers().getLayer(i).getName())) {

                                        isEqual = false;

                                }

                        }

                } else {

                        isEqual = false;

                }

                return isEqual;

        }

        public void addLayerError(String stringProperty) {

                layersError.add(stringProperty);

        }

        public ArrayList getLayersError() {