| gvSIG desktop 1

/* 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.layers;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.util.ArrayList;

import javax.print.attribute.PrintRequestAttributeSet;

import org.apache.log4j.Logger;

import org.cresques.cts.ICoordTrans;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.engine.data.NoSuchTableException;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.instruction.FieldNotFoundException;

import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException;

import com.iver.cit.gvsig.exceptions.layers.LegendLayerException;

import com.iver.cit.gvsig.exceptions.layers.ReloadLayerException;

import com.iver.cit.gvsig.exceptions.layers.StartEditionLayerException;

import com.iver.cit.gvsig.exceptions.visitors.StartWriterVisitorException;

import com.iver.cit.gvsig.exceptions.visitors.VisitorException;

import com.iver.cit.gvsig.fmap.ViewPort;

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

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

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

import com.iver.cit.gvsig.fmap.core.symbols.IMultiLayerSymbol;

import com.iver.cit.gvsig.fmap.core.symbols.ISymbol;

import com.iver.cit.gvsig.fmap.drivers.BoundedShapes;

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.drivers.IVectorialDatabaseDriver;

import com.iver.cit.gvsig.fmap.drivers.VectorialDriver;

import com.iver.cit.gvsig.fmap.drivers.WithDefaultLegend;

import com.iver.cit.gvsig.fmap.edition.AnnotationEditableAdapter;

import com.iver.cit.gvsig.fmap.edition.EditionEvent;

import com.iver.cit.gvsig.fmap.edition.ISpatialWriter;

import com.iver.cit.gvsig.fmap.edition.IWriteable;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.edition.VectorialEditableAdapter;

import com.iver.cit.gvsig.fmap.edition.VectorialEditableDBAdapter;

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

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

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

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

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

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.rendering.ILegend;

import com.iver.cit.gvsig.fmap.rendering.IVectorialLegend;

import com.iver.cit.gvsig.fmap.rendering.LegendChangedEvent;

import com.iver.cit.gvsig.fmap.rendering.LegendFactory;

import com.iver.cit.gvsig.fmap.rendering.SingleSymbolLegend;

import com.iver.cit.gvsig.fmap.rendering.ZSort;

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

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

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

import com.iver.cit.gvsig.fmap.spatialindex.IPersistentSpatialIndex;

import com.iver.cit.gvsig.fmap.spatialindex.ISpatialIndex;

import com.iver.cit.gvsig.fmap.spatialindex.QuadtreeGt2;

import com.iver.cit.gvsig.fmap.spatialindex.QuadtreeJts;

import com.iver.cit.gvsig.fmap.spatialindex.SpatialIndexException;

import com.iver.utiles.FileUtils;

import com.iver.utiles.IPersistance;

import com.iver.utiles.NotExistInXMLEntity;

import com.iver.utiles.PostProcessSupport;

import com.iver.utiles.XMLEntity;

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

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

/**

 * Capa b?sica Vectorial.

 *

 * @author Fernando Gonz?lez Cort?s

 */

// TODO Cuando no sea para pruebas debe no ser public

public class FLyrVect extends FLyrDefault implements ILabelable,

                ClassifiableVectorial, SingleLayer, VectorialData, RandomVectorialData,

                AlphanumericData, InfoByPoint {

        private static Logger logger = Logger.getLogger(FLyrVect.class.getName());

        /** Leyenda de la capa vectorial */

        private IVectorialLegend legend;

        private int typeShape = -1;

        private LayerChangeSupport layerChangeSupport = new LayerChangeSupport();

        private ReadableVectorial source;

        private SelectableDataSource sds;

        private SelectionSupport selectionSupport = new SelectionSupport();

        private SpatialCache spatialCache = new SpatialCache();

        private boolean spatialCacheEnabled = false;

        /**

         * An implementation of gvSIG spatial index

         */

        protected ISpatialIndex spatialIndex = null;

        private boolean bHasJoin = false;

        private XMLEntity orgXMLEntity = null;

        private XMLEntity loadSelection = null;

        private IVectorialLegend loadLegend = null;

        /**

         * Devuelve el VectorialAdapater de la capa.

         *

         * @return VectorialAdapter.

         */

        public ReadableVectorial getSource() {

                if (!this.isAvailable()) return null;

                return source;

        }

        /**

         * If we use a persistent spatial index associated with this layer, and the

         * index is not intrisic to the layer (for example spatial databases) this

         * method looks for existent spatial index, and loads it.

         *

         */

        private void loadSpatialIndex() {

                //FIXME: Al abrir el indice en fichero...

                //?C?mo lo liberamos? un metodo Layer.shutdown()

                ReadableVectorial source = getSource();

                //REVISAR QUE PASA CON LOS DRIVERS DXF, DGN, etc.

                //PUES SON VECTORIALFILEADAPTER

                if (!(source instanceof VectorialFileAdapter)) {

                        // we are not interested in db adapters

                        return;

                }

                VectorialDriver driver = source.getDriver();

                if (!(driver instanceof BoundedShapes)) {

                        // we dont spatially index layers that are not bounded

                        return;

                }

                File file = ((VectorialFileAdapter) source).getFile();

                String fileName = file.getAbsolutePath();

                File sptFile = new File(fileName + ".qix");

                if (!sptFile.exists() || (!(sptFile.length() > 0))) {

                        // before to exit, look for it in temp path

                        String tempPath = System.getProperty("java.io.tmpdir");

                        fileName = tempPath + File.separator + sptFile.getName();

                        sptFile = new File(fileName);

                        // it doesnt exists, must to create

                        if (!sptFile.exists() || (!(sptFile.length() > 0))) {

                                return;

                        }// if

                }// if

                try {

                        source.start();

                        spatialIndex = new QuadtreeGt2(FileUtils.getFileWithoutExtension(sptFile),

                                        "NM", source.getFullExtent(), source.getShapeCount(), false);

                        source.setSpatialIndex(spatialIndex);

                } catch (SpatialIndexException e) {

                        spatialIndex = null;

                        e.printStackTrace();

                        return;

                } catch (ReadDriverException e) {

                        spatialIndex = null;

                        e.printStackTrace();

                        return;

                } catch (ExpansionFileReadException e) {

                        spatialIndex = null;

                        e.printStackTrace();

                        return;

                }

        }

        /**

         * Checks if it has associated an external spatial index

         * (an spatial index file).

         *

         * It looks for it in main file path, or in temp system path.

         * If main file is rivers.shp, it looks for a file called

         * rivers.shp.qix.

         * @return

         */

        public boolean isExternallySpatiallyIndexed() {

                /*

                 * FIXME (AZABALA): Independizar del tipo de fichero de ?ndice

                  * con el que se trabaje (ahora mismo considera la extension .qix,

             * pero esto depender? del tipo de ?ndice)

                 * */

                ReadableVectorial source = getSource();

                if (!(source instanceof VectorialFileAdapter)) {

                        // we are not interested in db adapters.

                        // think in non spatial dbs, like HSQLDB

                        return false;

                }

                File file = ((VectorialFileAdapter) source).getFile();

                String fileName = file.getAbsolutePath();

                File sptFile = new File(fileName + ".qix");

                if (!sptFile.exists() || (!(sptFile.length() > 0))) {

                        // before to exit, look for it in temp path

                        // it doesnt exists, must to create

                        String tempPath = System.getProperty("java.io.tmpdir");

                        fileName = tempPath + File.separator + sptFile.getName();

                        sptFile = new File(fileName);

                        if (!sptFile.exists() || (!(sptFile.length() > 0))) {

                                return false;

                        }// if

                }// if

                return true;

        }

        /**

         * Inserta el VectorialAdapter a la capa.

         *

         * @param va

         *            VectorialAdapter.

         */

        public void setSource(ReadableVectorial rv) {

                source = rv;

                // azabala: we check if this layer could have a file spatial index

                // and load it if it exists

                loadSpatialIndex();

        }

        public Rectangle2D getFullExtent() throws ReadDriverException, ExpansionFileReadException {

                        Rectangle2D rAux;

                        source.start();

                        rAux = (Rectangle2D)source.getFullExtent().clone();

                        source.stop();

                        // Si existe reproyecci?n, reproyectar el extent

                        ICoordTrans ct = getCoordTrans();

                        if (ct != null) {

                                Point2D pt1 = new Point2D.Double(rAux.getMinX(), rAux.getMinY());

                                Point2D pt2 = new Point2D.Double(rAux.getMaxX(), rAux.getMaxY());

                                pt1 = ct.convert(pt1, null);

                                pt2 = ct.convert(pt2, null);

                                rAux = new Rectangle2D.Double();

                                rAux.setFrameFromDiagonal(pt1, pt2);

                        }

                        //Esto es para cuando se crea una capa nueva con el fullExtent de ancho y alto 0.

                        if (rAux.getWidth()==0 && rAux.getHeight()==0) {

                                rAux=new Rectangle2D.Double(0,0,100,100);

                        }

                        return rAux;

        }

        public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

                        Cancellable cancel, double scale) throws ReadDriverException {

// FEATURE ITERATORS (TEST METHOD)

                if (isWithinScale(scale)) {

                        // Las que solo tienen etiquetado sin pintar el shape,

                        // no pasamos por ellas

                        boolean bDrawShapes = true;

                        if (legend instanceof SingleSymbolLegend) {

                                if (legend.getDefaultSymbol().isShapeVisible() == false)

                                        bDrawShapes = false;

                        }

                        if (bDrawShapes) {

                                try {

                                        prepareDrawing(image, g, viewPort);

                                        ArrayList fieldList = new ArrayList();

                                        // fields from legend

                                        String[] aux = legend.getUsedFields();

                                        for (int i = 0; i < aux.length; i++) {

                                                fieldList.add(aux[i]);

                                        }

                                        // fields from labeling

                                        if (isLabeled()) {

                                                aux = getLabelingStrategy().getUsedFields();

                                                for (int i = 0; i < aux.length; i++) {

                                                        fieldList.add(aux[i]);

                                                }

                                        }

                                        IFeatureIterator it = getSource().getFeatureIterator(

                                                        viewPort.getAdjustedExtent(),

                                                        //(String[]) fieldList.toArray(new String[fieldList.size()]),

                                                        null,

                                                        getProjection(), true);

                                        ZSort zSort = ((IVectorialLegend) getLegend()).getZSort();

                                        if (zSort != null && zSort.isUsingZSort()) {

                                                BufferedImage[] imageLevels = new BufferedImage[zSort.getLevelCount()+1];

                                                Graphics2D[] graphics = new Graphics2D[imageLevels.length];

                                                for (int i = 0; !cancel.isCanceled() && i < imageLevels.length; i++) {

                                                        imageLevels[i] = new BufferedImage(image.getWidth(), image.getHeight(), image.getType());

                                                        graphics[i] = imageLevels[i].createGraphics();

                                                }

                                                // -- visual FX stuff

                                                int screenRefreshRate = 1000; // render temporary map each screenRefreshRate milliseconds;

                                                long time = System.currentTimeMillis();

                                                BufferedImage virtualBim;

                                                Graphics2D virtualGraphics;

                                                // -- end visual FX stuff

                                                while ( !cancel.isCanceled() && it.hasNext()) {

                                                        IFeature feat = it.next();

                                                        IGeometry geom = feat.getGeometry();

                                                        ISymbol sym = legend.getSymbolByFeature(feat);

                                                        if (sym instanceof IMultiLayerSymbol) {

                                                                IMultiLayerSymbol mlSym = (IMultiLayerSymbol) sym;

                                                                for (int i = 0; i < mlSym.getLayerCount(); i++) {

                                                                        ISymbol mySym = mlSym.getLayer(i);

                                                                        geom.drawInts(graphics[zSort.getSymbolLevel(mySym)], viewPort, mySym);

                                                                }

                                                        } else {

                                                                geom.drawInts(graphics[zSort.getSymbolLevel(sym)], viewPort, sym);

                                                        }

                                                        // -- visual FX stuff

                                                        if ((System.currentTimeMillis() - time) > screenRefreshRate) {

                                                                time = System.currentTimeMillis();

                                                                virtualBim = new BufferedImage(image.getWidth(),image.getHeight(),BufferedImage.TYPE_INT_ARGB);

                                                                virtualGraphics = virtualBim.createGraphics();

                                                                virtualGraphics.drawImage(image,0,0,null);

                                                                for (int i = 0; i < imageLevels.length; i++) {

                                                                        virtualGraphics.drawImage(imageLevels[i],0,0, null);

                                                                }

                                                                g.clearRect(0, 0, image.getWidth(), image.getHeight());

                                                                g.drawImage(virtualBim, 0, 0, null);

                                                        }

                                                        // -- end visual FX stuff

                                                }

                                                g.drawImage(image, 0, 0, null);

                                                for (int i = 0; i < imageLevels.length; i++) {

                                                        g.drawImage(imageLevels[i],0,0, null);

                                                        imageLevels[i] = null;

                                                        graphics[i] = null;

                                                }

                                                imageLevels = null;

                                                graphics = null;

                                        } else {

                                                while ( !cancel.isCanceled() && it.hasNext() ) {

                                                        IFeature feat = it.next();

                                                        ISymbol sym = legend.getSymbolByFeature(feat);

                                                        IGeometry geom = feat.getGeometry();

                                                        geom.drawInts(g, viewPort, sym);

                                                }

                                        }

                                } catch (ReadDriverException e) {

                                        this.setVisible(false);

                                        this.setActive(false);

                                        throw e;

                                } catch (ExpansionFileReadException e) {

                                        this.setVisible(false);

                                        this.setActive(false);

//                                        throw new DriverException(e);

                                        // TODO throw a correct exception (??? ReadDriverException ???)

                                        e.printStackTrace();

                                }

                        }

                        if (getVirtualLayers() != null) {

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

                        }

                }

        }

        public void _draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

                        Cancellable cancel, double scale) throws ReadDriverException {

                if (isWithinScale(scale)) {

                        // Las que solo tienen etiquetado sin pintar el shape,

                        // no pasamos por ellas

                        boolean bDrawShapes = true;

                        if (legend instanceof SingleSymbolLegend) {

                                if (legend.getDefaultSymbol().isShapeVisible() == false)

                                        bDrawShapes = false;

                        }

                        if (bDrawShapes) {

                                Strategy strategy = StrategyManager.getStrategy(this);

                                try {

                                        prepareDrawing(image, g, viewPort);

                                        strategy.draw(image, g, viewPort, cancel);

                                } catch (ReadDriverException e) {

                                        this.setVisible(false);

                                        this.setActive(false);

                                        throw e;

                                }

                        }

                        if (getVirtualLayers() != null) {

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

                        }

                }

        }

        /**

         * Se llama antes de empezar a pintar.

         * Es ?til para preparar la cache a emplear, las leyendas, etc.

         * @param image

         * @param g

         * @param viewPort

         */

        private void prepareDrawing(BufferedImage image, Graphics2D g, ViewPort viewPort) {

        }

        public void _print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

                        double scale, PrintRequestAttributeSet properties) throws ReadDriverException {

                // TEST METHOD

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

        }

        public void print(Graphics2D g, ViewPort viewPort, Cancellable cancel,

                        double scale, PrintRequestAttributeSet properties) throws ReadDriverException {

                if (isVisible() && isWithinScale(scale)) {

                        Strategy strategy = StrategyManager.getStrategy(this);

                        strategy.print(g, viewPort, cancel, properties);

                        ILabelingStrategy labeling;

                        if ( (labeling = getLabelingStrategy() ) != null) {

                                // contains labels

                                labeling.print(g, viewPort, cancel, properties);

                        }

                }

        }

        public void deleteSpatialIndex() {

                //must we delete possible spatial indexes files?

                spatialIndex = null;

        }

   /**

    * <p>

    * Creates an spatial index associated to this layer.

    * The spatial index will used

    * the native projection of the layer, so if the layer is reprojected, it will

    * be ignored.

    * </p>

    * @param cancelMonitor instance of CancellableMonitorable that allows

    * to monitor progress of spatial index creation, and cancel the process

    */

    public void createSpatialIndex(CancellableMonitorable cancelMonitor){

             // FJP: ESTO HABR? QUE CAMBIARLO. PARA LAS CAPAS SECUENCIALES, TENDREMOS

        // QUE ACCEDER CON UN WHILE NEXT. (O mejorar lo de los FeatureVisitor

        // para que acepten recorrer sin geometria, solo con rectangulos.

            //If this vectorial layer is based in a spatial database, the spatial

                //index is already implicit. We only will index file drivers

            ReadableVectorial va = getSource();

            //We must think in non spatial databases, like HSQLDB

                if(!(va instanceof VectorialFileAdapter)){

                        return;

                }

                if (!(va.getDriver() instanceof BoundedShapes)) {

                        return;

                }

                File file = ((VectorialFileAdapter) va).getFile();

                String fileName = file.getAbsolutePath();

                ISpatialIndex localCopy = null;

                try {

                        va.start();

                        localCopy = new QuadtreeGt2(fileName, "NM", va.getFullExtent(),

                                        va.getShapeCount(), true);

                } catch (SpatialIndexException e1) {

                        // Probably we dont have writing permissions

                        String directoryName = System.getProperty("java.io.tmpdir");

                        File newFile = new File(directoryName +

                                        File.separator +

                                        file.getName());

                        String newFileName = newFile.getName();

                        try {

                                localCopy = new QuadtreeGt2(newFileName, "NM", va.getFullExtent(),

                                                va.getShapeCount(), true);

                        } catch (SpatialIndexException e) {

                                // if we cant build a file based spatial index, we'll build

                                // a pure memory spatial index

                                localCopy = new QuadtreeJts();

                        } catch (ReadDriverException e) {

                                localCopy = new QuadtreeJts();

                        } catch (ExpansionFileReadException e) {

                                localCopy = new QuadtreeJts();

                        }

                }catch(Exception e){

                        e.printStackTrace();

                }//try

        BoundedShapes shapeBounds = (BoundedShapes) va.getDriver();

        try {

            for (int i=0; i < va.getShapeCount(); i++)

            {

                    if(cancelMonitor != null){

                            if(cancelMonitor.isCanceled())

                                    return;

                            cancelMonitor.reportStep();

                    }

                Rectangle2D r = shapeBounds.getShapeBounds(i);

                if(r != null)

                        localCopy.insert(r, i);

            } // for

            va.stop();

            if(localCopy instanceof IPersistentSpatialIndex)

                    ((IPersistentSpatialIndex) localCopy).flush();

            spatialIndex = localCopy;

            //vectorial adapter needs a reference to the spatial index, to solve

            //request for feature iteration based in spatial queries

            source.setSpatialIndex(spatialIndex);

        } catch (ReadDriverException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                } catch (ExpansionFileReadException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

    }

        public void createSpatialIndex() {

                createSpatialIndex(null);

        }

        public void process(FeatureVisitor visitor, FBitSet subset)

                        throws ReadDriverException, ExpansionFileReadException, VisitorException {

                Strategy s = StrategyManager.getStrategy(this);

                s.process(visitor, subset);

        }

        public void process(FeatureVisitor visitor) throws ReadDriverException, VisitorException {

                Strategy s = StrategyManager.getStrategy(this);

                s.process(visitor);

        }

        public void process(FeatureVisitor visitor, Rectangle2D rect)

                        throws ReadDriverException, ExpansionFileReadException, VisitorException {

                Strategy s = StrategyManager.getStrategy(this);

                s.process(visitor, rect);

        }

        public FBitSet queryByRect(Rectangle2D rect) throws ReadDriverException, VisitorException {

                Strategy s = StrategyManager.getStrategy(this);

                return s.queryByRect(rect);

        }

        public FBitSet queryByPoint(Point2D p, double tolerance)

                        throws ReadDriverException, VisitorException {

                Strategy s = StrategyManager.getStrategy(this);

                return s.queryByPoint(p, tolerance);

        }

        public FBitSet queryByShape(IGeometry g, int relationship)

                        throws ReadDriverException, VisitorException {

                Strategy s = StrategyManager.getStrategy(this);

                return s.queryByShape(g, relationship);

        }

        public XMLItem[] getInfo(Point p, double tolerance, Cancellable cancel) throws ReadDriverException, VisitorException {

                Point2D pReal = this.getMapContext().getViewPort().toMapPoint(p);

                FBitSet bs = queryByPoint(pReal, tolerance);

                VectorialXMLItem[] item = new VectorialXMLItem[1];

                item[0] = new VectorialXMLItem(bs, this);

                return item;

        }

        public void setLegend(IVectorialLegend r) throws LegendLayerException {

                IVectorialLegend oldLegend = legend;

                legend = r;

                try {

                        legend.setDataSource(getRecordset());

                } catch (FieldNotFoundException e1) {

                        throw new LegendLayerException(getName(),e1);

                } catch (ReadDriverException e1) {

                        throw new LegendLayerException(getName(),e1);

                }

                LegendChangedEvent e = LegendChangedEvent.createLegendChangedEvent(

                                oldLegend, legend);

                callLegendChanged(e);

        }

        /**

         * Devuelve la Leyenda de la capa.

         *

         * @return Leyenda.

         */

        public ILegend getLegend() {

                return legend;

        }

        /**

         * Devuelve el tipo de shape que contiene la capa.

         *

         * @return tipo de shape.

         *

         * @throws DriverException

         */

        public int getShapeType() throws ReadDriverException {

                if (typeShape == -1) {

                        getSource().start();

                        typeShape = getSource().getShapeType();

                        getSource().stop();

                }

                return typeShape;

        }

        public XMLEntity getXMLEntity() throws XMLException {

                if (!this.isAvailable() && this.orgXMLEntity != null) {

                        return this.orgXMLEntity;

                }

                XMLEntity xml = super.getXMLEntity();

                if (getLegend()!=null)

                        xml.addChild(getLegend().getXMLEntity());

                try {

                        if (getRecordset()!=null)

                                xml.addChild(getRecordset().getSelectionSupport().getXMLEntity());

                } catch (ReadDriverException e1) {

                        e1.printStackTrace();

                        throw new XMLException(e1);

                }

                // Repongo el mismo ReadableVectorial m?s abajo para cuando se guarda el proyecto.

                ReadableVectorial rv=getSource();

                xml.putProperty("type", "vectorial");

                if (source instanceof VectorialEditableAdapter) {

                        setSource(((VectorialEditableAdapter) source).getOriginalAdapter());

                }

                if (source instanceof VectorialFileAdapter) {

                        xml.putProperty("type", "vectorial");

                        xml.putProperty("file", ((VectorialFileAdapter) source)

                                        .getFile());

                        try {

                                xml.putProperty("recordset-name", source.getRecordset()

                                                .getName());

                        } catch (ReadDriverException e) {

                                throw new XMLException(e);

                        } catch (RuntimeException e) {

                                e.printStackTrace();

                        }

                } else if (source instanceof VectorialDBAdapter) {

                        xml.putProperty("type", "vectorial");

                        IVectorialDatabaseDriver dbDriver = (IVectorialDatabaseDriver) source

                                        .getDriver();

                        // Guardamos el nombre del driver para poder recuperarlo

                        // con el DriverManager de Fernando.

                        xml.putProperty("db", dbDriver.getName());

                        try {

                                xml.putProperty("recordset-name", source.getRecordset()

                                                .getName());

                        } catch (ReadDriverException e) {

                                throw new XMLException(e);

                        } catch (RuntimeException e) {

                                e.printStackTrace();

                        }

                        xml.addChild(dbDriver.getXMLEntity()); // Tercer child. Antes hemos

                                                                                                        // metido la leyenda y el

                                                                                                        // selection support

                } else if (source instanceof VectorialAdapter) {

                        // Se supone que hemos hecho algo gen?rico.

                        xml.putProperty("type", "vectorial");

                        VectorialDriver driver = source.getDriver();

                        // Guardamos el nombre del driver para poder recuperarlo

                        // con el DriverManager de Fernando.

                        xml.putProperty("other", driver.getName());

                        // try {

                        try {

                                xml.putProperty("recordset-name", source.getRecordset()

                                                .getName());

                        } catch (ReadDriverException e) {

                                throw new XMLException(e);

                        } catch (RuntimeException e) {

                                e.printStackTrace();

                        }

                        if (driver instanceof IPersistance) {

                                // xml.putProperty("className", driver.getClass().getName());

                                IPersistance persist = (IPersistance) driver;

                                xml.addChild(persist.getXMLEntity()); // Tercer child. Antes

                                                                                                                // hemos metido la

                                                                                                                // leyenda y el

                                                                                                                // selection support

                        }

                }

                if (rv!=null)

                        setSource(rv);

                xml.putProperty("driverName", source.getDriver().getName());

                if (bHasJoin)

                        xml.putProperty("hasJoin", "true");

                // properties from ILabelable

                xml.putProperty("isLabeled", isLabeled);

                if (strategy != null) {

                        XMLEntity strategyXML = strategy.getXMLEntity();

                        strategyXML.putProperty("Strategy", strategy.getClassName());

                        xml.addChild(strategy.getXMLEntity());

                }

                return xml;

        }

        /**

         * @see com.iver.cit.gvsig.fmap.layers.FLyrDefault#setXMLEntity(com.iver.utiles.XMLEntity)

         */

        public void setXMLEntity03(XMLEntity xml) throws XMLException {

                super.setXMLEntity(xml);

                legend = LegendFactory.createFromXML03(xml.getChild(0));

                try {

                        setLegend(legend);

                } catch (LegendLayerException e) {

                        throw new XMLException(e);

                }

                try {

                        getRecordset().getSelectionSupport()

                                        .setXMLEntity03(xml.getChild(1));

                } catch (ReadDriverException e) {

                        e.printStackTrace();

                }

        }

        /*

         * @see com.iver.cit.gvsig.fmap.layers.FLyrDefault#setXMLEntity(com.iver.utiles.XMLEntity)

         */

        public void setXMLEntity(XMLEntity xml) throws XMLException {

                try {

                        super.setXMLEntity(xml);

                        XMLEntity legendXML = xml.getChild(0);

                        IVectorialLegend leg = LegendFactory.createFromXML(legendXML);

                        /* (jaume) begin patch;

                     * for backward compatibility purposes. Since gvSIG v1.1 labeling is

                     * no longer managed by the Legend but by the ILabelingStrategy. The

                     * following allows restoring older projects' labelings.

                     */

                        if (legendXML.contains("labelFieldName")) {

                                String labelTextField = legendXML.getStringProperty("labelFieldName");

                                if (labelTextField != null) {

                                        AttrInTableLabeling labeling = new AttrInTableLabeling();

                                        labeling.setLayer(this);

                                        labeling.setTextField(legendXML.getStringProperty("labelFieldName"));

                                        labeling.setHeightField(legendXML.getStringProperty("labelHeightFieldName"));

                                        labeling.setRotationField(legendXML.getStringProperty("labelRotationFieldName"));

                                        this.setLabelingStrategy(labeling);

                                        this.setIsLabeled(true);

                                }

                      }

                    /* end patch */

                        try {

                                getRecordset().getSelectionSupport().setXMLEntity(xml.getChild(1));

                                // JMVIVO: Esto sirve para algo????

                                String recordsetName = xml.getStringProperty("recordset-name");

                                LayerFactory.getDataSourceFactory().changeDataSourceName(

                                                getSource().getRecordset().getName(), recordsetName);

                        } catch (NoSuchTableException e1) {

                                this.setAvailable(false);

                                throw new XMLException(e1);

                        } catch (ReadDriverException e1) {

                                this.setAvailable(false);

                                throw new XMLException(e1);

                        }

                        // Si tiene una uni?n, lo marcamos para que no se cree la leyenda hasta

                        // el final

                        // de la lectura del proyecto

                        if (xml.contains("hasJoin")) {

                                setIsJoined(true);

                                PostProcessSupport.addToPostProcess(this, "setLegend", leg, 1);

                        } else {

                                try {

                                        setLegend(leg);

                                } catch (LegendLayerException e) {

                                        throw new XMLException(e);

                                }

                        }

                        // set properties for ILabelable

                        for (int i = 0; i < xml.getChildrenCount(); i++) {

                                try {

                                        if (xml.getChild(i).contains("Strategy")) {

                                                XMLEntity xmlStrategy = xml.getChild(i);

                                                this.strategy = LabelingFactory.createStrategyFromXML(xmlStrategy.getChild(0));

                                        }

                                } catch (NotExistInXMLEntity neXMLEX) {

                                        // no strategy was set, just continue;

                                        logger.warn("Reached what should be unreachable code");

                                }

                        }

                } catch (XMLException e) {

                        this.setAvailable(false);

                        this.orgXMLEntity = xml;

                } catch (Exception e) {

                        e.printStackTrace();

                        this.setAvailable(false);

                        this.orgXMLEntity = xml;

                }

        }

        public void setXMLEntityNew(XMLEntity xml) throws XMLException {

                try {

                        super.setXMLEntity(xml);

                        XMLEntity legendXML = xml.getChild(0);

                        IVectorialLegend leg = LegendFactory.createFromXML(legendXML);

                        /* (jaume) begin patch;

                     * for backward compatibility purposes. Since gvSIG v1.1 labeling is

                     * no longer managed by the Legend but by the ILabelingStrategy. The

                     * following allows restoring older projects' labelings.

                     */

                    if (legendXML.contains("labelFieldHeight")) {

                            AttrInTableLabeling labeling = new AttrInTableLabeling();

                            labeling.setLayer(this);

                            labeling.setTextField(legendXML.getStringProperty("labelFieldHeight"));

                            labeling.setRotationField(legendXML.getStringProperty("labelFieldRotation"));

                            this.setLabelingStrategy(labeling);

                            this.setIsLabeled(true);

                      }

                    /* end patch */

                        try {

                                getRecordset().getSelectionSupport().setXMLEntity(xml.getChild(1));

                                this.setLoadSelection(xml.getChild(1));

                        } catch (ReadDriverException e1) {

                                this.setAvailable(false);

                                throw new XMLException(e1);

                        }

                        // Si tiene una uni?n, lo marcamos para que no se cree la leyenda hasta

                        // el final

                        // de la lectura del proyecto

                        if (xml.contains("hasJoin")) {

                                setIsJoined(true);

                                PostProcessSupport.addToPostProcess(this, "setLegend", leg, 1);

                        } else {

                                this.setLoadLegend(leg);

                        }

                } catch (XMLException e) {

                        this.setAvailable(false);

                        this.orgXMLEntity = xml;

                } catch (Exception e) {

                        this.setAvailable(false);

                        this.orgXMLEntity = xml;

                }

        }

        /**

         * A?ade un LegendListener a la lista de Listeners.

         *

         * @param listener

         *            LegendListener.

         */

        public void addLegendListener(LegendListener listener) {

                layerChangeSupport.addLayerListener(listener);

        }

        /**

         * Llamada al m?todo callLegendChanged de los listener.

         *

         * @param e

         *            Evento.

         */

        private void callLegendChanged(LegendChangedEvent e) {

                layerChangeSupport.callLegendChanged(e);

        }

        /**

         * Borra un LegendListener de la lista de Listeners

         *

         * @param listener

         *            LegendListener.

         */

        public void removeLegendListener(LegendListener listener) {

                layerChangeSupport.removeLayerListener(listener);

        }

        /**

         * Sobreimplementaci?n del m?todo toString para que las bases de datos

         * identifiquen la capa.

         *

         * @return DOCUMENT ME!

         */

        public String toString() {

                /*

                 * Se usa internamente para que la parte de datos identifique de forma

                 * un?voca las tablas

                 */

                String ret = super.toString();

                return "layer" + ret.substring(ret.indexOf('@') + 1);

        }

        public boolean isJoined() {

                return bHasJoin;

        }

        /**

         * Returns if a layer is spatially indexed

         *

         * @return if this layer has the ability to proces spatial queries without

         *         secuential scans.

         */

        public boolean isSpatiallyIndexed() {

                ReadableVectorial source = getSource();

                if (source instanceof ISpatialDB)

                        return true;

//FIXME azabala

/*

 * Esto es muy dudoso, y puede cambiar.

 * Estoy diciendo que las que no son fichero o no son

 * BoundedShapes estan indexadas. Esto es mentira, pero

 * as? quien pregunte no querr? generar el indice.

 * Esta por ver si interesa generar el indice para capas

 * HSQLDB, WFS, etc.

 */

                if(!(source instanceof VectorialFileAdapter)){

                        return true;

                }

                if (!(source.getDriver() instanceof BoundedShapes)) {

                        return true;

                }

                if (getISpatialIndex() != null)

                        return true;

                return false;

        }

        public void setIsJoined(boolean hasJoin) {

                bHasJoin = hasJoin;

        }

        /**

         * @return Returns the spatialIndex.

         */

        public ISpatialIndex getISpatialIndex() {

                return spatialIndex;

        }

        /**

         * Sets the spatial index. This could be useful if, for some

         * reasons, you want to work with a distinct spatial index

         * (for example, a spatial index which could makes nearest

         * neighbour querys)

         * @param spatialIndex

         */

        public void setISpatialIndex(ISpatialIndex spatialIndex){

                this.spatialIndex = spatialIndex;

        }

        public SelectableDataSource getRecordset() throws ReadDriverException {

                if (!this.isAvailable()) return null;

                if (sds == null) {

                                SelectableDataSource ds = source.getRecordset();

                                if (ds == null) {

                                        return null;

                                }

                                sds = ds;

                                sds.setSelectionSupport(selectionSupport);

                }

                return sds;

        }

        public void setEditing(boolean b) throws StartEditionLayerException {

                super.setEditing(b);

                try {

                        if (b) {

                                VectorialEditableAdapter vea = null;

                                // TODO: Qu? pasa si hay m?s tipos de adapters?

                                // FJP: Se podr?a pasar como argumento el

                                // VectorialEditableAdapter

                                // que se quiera usar para evitar meter c?digo aqu? de este

                                // estilo.

                                if (getSource() instanceof VectorialDBAdapter) {

                                        vea = new VectorialEditableDBAdapter();

                                } else if (this instanceof FLyrAnnotation) {

                                        vea = new AnnotationEditableAdapter(

                                                        (FLyrAnnotation) this);

                                } else {

                                        vea = new VectorialEditableAdapter();

                                }

                                vea.setOriginalVectorialAdapter(getSource());

//                                azo: implementations of readablevectorial need

                                //references of projection and spatial index

                                vea.setProjection(getProjection());

                                vea.setSpatialIndex(spatialIndex);

                                // /vea.setSpatialIndex(getSpatialIndex());

                                // /vea.setFullExtent(getFullExtent());

                                vea.startEdition(EditionEvent.GRAPHIC);

                                setSource(vea);

                                getRecordset().setSelectionSupport(

                                                vea.getOriginalAdapter().getRecordset()

                                                                .getSelectionSupport());

                        } else {

                                VectorialEditableAdapter vea = (VectorialEditableAdapter) getSource();

                                setSource(vea.getOriginalAdapter());

                        }

                        // Si tenemos una leyenda, hay que pegarle el cambiazo a su

                        // recordset

                        setRecordset(getSource().getRecordset());

                        if (getLegend() instanceof IVectorialLegend) {

                                IVectorialLegend ley = (IVectorialLegend) getLegend();

                                ley.setDataSource(getSource().getRecordset());

                                // Esto lo pongo para evitar que al dibujar sobre un

                                // dxf, dwg, o dgn no veamos nada. Es debido al checkbox

                                // de la leyenda de textos "dibujar solo textos".

//jaume

//                                if (!(getSource().getDriver() instanceof IndexedShpDriver)){

//                                        FSymbol symbol=new FSymbol(getShapeType());

//                                        symbol.setFontSizeInPixels(false);

//                                        symbol.setFont(new Font("SansSerif", Font.PLAIN, 9));

//                                        Color color=symbol.getColor();

//                                        int alpha=symbol.getColor().getAlpha();

//                                        if (alpha>250) {

//                                                symbol.setColor(new Color(color.getRed(),color.getGreen(),color.getBlue(),100));

//                                        }

//                                        ley.setDefaultSymbol(symbol);

//                                }

//jaume//

                                ley.useDefaultSymbol(true);

                        }

                } catch (ReadDriverException e) {

                        throw new StartEditionLayerException(getName(),e);

                } catch (FieldNotFoundException e) {

                        throw new StartEditionLayerException(getName(),e);

                } catch (StartWriterVisitorException e) {

                        throw new StartEditionLayerException(getName(),e);

                }

                setSpatialCacheEnabled(b);

                callEditionChanged(LayerEvent

                                .createEditionChangedEvent(this, "edition"));

        }

        /**

         * Para cuando haces una uni?n, sustituyes el recorset por el nuevo. De esta

         * forma, podr?s poner leyendas basadas en el nuevo recordset

         *

         * @param newSds

         */

        public void setRecordset(SelectableDataSource newSds) {

                sds = newSds;

                sds.setSelectionSupport(selectionSupport);

        }

        public void clearSpatialCache()

        {

                spatialCache.clearAll();

        }

        public boolean isSpatialCacheEnabled() {

                return spatialCacheEnabled;

        }

        public void setSpatialCacheEnabled(boolean spatialCacheEnabled) {

                this.spatialCacheEnabled = spatialCacheEnabled;

        }

        public SpatialCache getSpatialCache() {

                return spatialCache;

        }

        /**

         * Siempre es un numero mayor de 1000

         * @param maxFeatures

         */

        public void setMaxFeaturesInEditionCache(int maxFeatures) {

                if (maxFeatures > spatialCache.maxFeatures)

                        spatialCache.setMaxFeatures(maxFeatures);

        }

        /**

         * This method returns a boolean that is used by the FPopMenu

         * to make visible the properties menu or not. It is visible by

         * default, and if a later don't have to show this menu only

         * has to override this method.

         * @return

         * If the properties menu is visible (or not)

         */

        public boolean isPropertiesMenuVisible(){

                return true;

        }

        public void reload() throws ReloadLayerException {

                this.setAvailable(true);

                super.reload();

                try {

                        this.source.getDriver().reload();

                        if (this.getLegend() == null) {

                    if (this.getRecordset().getDriver() instanceof WithDefaultLegend) {

                        WithDefaultLegend aux = (WithDefaultLegend) this.getRecordset().getDriver();

                        this.setLegend((IVectorialLegend) aux.getDefaultLegend());

                        this.setLabelingStrategy(aux.getDefaultLabelingStrategy());

                    } else {

                        this.setLegend(LegendFactory.createSingleSymbolLegend(

                                this.getShapeType()));

                    }

                        }

                } catch (LegendLayerException e) {

                        this.setAvailable(false);

                        throw new ReloadLayerException(getName(),e);

                } catch (ReadDriverException e) {

                        this.setAvailable(false);

                        throw new ReloadLayerException(getName(),e);

                }

        }

        protected void setLoadSelection(XMLEntity xml) {

                this.loadSelection = xml;

        }

        protected void setLoadLegend(IVectorialLegend legend) {

                this.loadLegend = legend;

        }

        protected void putLoadSelection() throws XMLException {

                if (this.loadSelection == null) return;

                try {

                        this.getRecordset().getSelectionSupport().setXMLEntity(this.loadSelection);

                } catch (ReadDriverException e) {

                        throw new XMLException(e);

                }

                this.loadSelection = null;

        }

        protected void putLoadLegend() throws LegendLayerException {

                if (this.loadLegend == null) return;

                this.setLegend(this.loadLegend);

                this.loadLegend = null;

        }

        protected void cleanLoadOptions() {

                this.loadLegend = null;

                this.loadSelection = null;

        }

        public boolean isWritable() {

                VectorialDriver drv = getSource().getDriver();

                if (!drv.isWritable())

                        return false;

                if (drv instanceof IWriteable)

                {

                        IWriter writer = ((IWriteable)drv).getWriter();

                        if (writer != null)

                        {

                                if (writer instanceof ISpatialWriter)

                                        return true;

                        }

                }

                return false;

        }

//        public void beforePrinting(PrintRequestAttributeSet properties) {

//                VectorialLegend vl=(VectorialLegend)getLegend();

//                if (vl instanceof ClassifiedLegendInfo) {

//                        ClassifiedLegendInfo clsfLegend = (ClassifiedLegendInfo) vl;

//                        IPrintable[] symbols=clsfLegend.getSymbols();

//                        for (int i=0;i<symbols.length;i++) {

//                                symbols[i].setPrintingProperties(properties);

//                        }

//                }

//                if (vl.getDefaultSymbol()!=null) {

//                        ((IPrintable)vl.getDefaultSymbol()).setPrintingProperties(properties);

//                }

//        }

//

//        public void afterPrinting() {

//                VectorialLegend vl=(VectorialLegend)getLegend();

//                if (vl instanceof ClassifiedLegendInfo) {

//                        ClassifiedLegendInfo clsfLegend = (ClassifiedLegendInfo) vl;

//                        IPrintable[] symbols=clsfLegend.getSymbols();

//                        for (int i=0;i<symbols.length;i++) {

//                                symbols[i].setPrintingProperties(null);

//                        }

//                }

//                if (vl.getDefaultSymbol()!=null) {

//                        ((IPrintable)vl.getDefaultSymbol()).setPrintingProperties(null);

//                }

//

//        }

        public FLayer cloneLayer() throws Exception {

                FLyrVect clonedLayer = new FLyrVect();

                clonedLayer.setSource(getSource());

                clonedLayer.setVisible(isVisible());

                clonedLayer.setISpatialIndex(getISpatialIndex());

                clonedLayer.setName(getName());

                clonedLayer.setCoordTrans(getCoordTrans());

                clonedLayer.setLegend((IVectorialLegend)getLegend());

                clonedLayer.setIsLabeled(isLabeled());

                clonedLayer.setLabelingStrategy(getLabelingStrategy());

                return clonedLayer;

        }

        /*

         * jaume. Stuff from ILabeled.

         */

        private boolean isLabeled;

        private ILabelingStrategy strategy;

        public boolean isLabeled() {

                return isLabeled;

        }

        public void setIsLabeled(boolean isLabeled) {

                this.isLabeled = isLabeled;

        }

        public ILabelingStrategy getLabelingStrategy() {

                return strategy;

        }

        public void setLabelingStrategy(ILabelingStrategy strategy) {

                this.strategy = strategy;

        }

        public void drawLabels(BufferedImage image, Graphics2D g, ViewPort viewPort, Cancellable cancel, double scale) throws ReadDriverException {

                if (isWithinScale(scale)) {

                        strategy.draw(image, g, viewPort, cancel);

                }

        }

}