| 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 org.gvsig.fmap.mapcontext.layers.vectorial;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.util.Set;

import java.util.TreeSet;

import org.cresques.cts.ICoordTrans;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.print.PrintAttributes;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureStoreNotification;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.exception.CreateGeometryException;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Circle;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.ViewPort;

import org.gvsig.fmap.mapcontext.exceptions.LegendLayerException;

import org.gvsig.fmap.mapcontext.exceptions.LoadLayerException;

import org.gvsig.fmap.mapcontext.exceptions.ReloadLayerException;

import org.gvsig.fmap.mapcontext.exceptions.ReprojectLayerException;

import org.gvsig.fmap.mapcontext.exceptions.StartEditionLayerException;

import org.gvsig.fmap.mapcontext.exceptions.StopEditionLayerException;

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.ILegend;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorLegend;

import org.gvsig.fmap.mapcontext.rendering.legend.LegendException;

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

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

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

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

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

import org.gvsig.fmap.mapcontext.rendering.legend.styling.ILabelingStrategy;

import org.gvsig.fmap.mapcontext.rendering.symbols.CartographicSupport;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObjectSet;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.dynobject.exception.DynMethodNotSupportedException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.persistence.exception.PersistenceRuntimeException;

import org.gvsig.tools.task.Cancellable;

/**

 * Capa b?sica Vectorial.

 * 

 * @author Fernando Gonz?lez Cort?s

 */

public class FLyrVect extends FLyrDefault implements VectorLayer,

LegendContentsChangedListener, Observer {

    final static private org.slf4j.Logger logger =

        LoggerFactory.getLogger(FLyrVect.class);

    private final GeometryManager geomManager =

        GeometryLocator.getGeometryManager();

    /** Leyenda de la capa vectorial */

    private IVectorLegend legend;

    private int typeShape = -1;

    private FeatureStore featureStore = null;

    private SpatialCache spatialCache = new SpatialCache();

    /**

     * An implementation of gvSIG spatial index

     */

    // protected ISpatialIndex spatialIndex = null;

    private IVectorLegend loadLegend = null;

    private boolean isLabeled;

    protected ILabelingStrategy strategy;

//        private ReprojectDefaultGeometry reprojectTransform;

    public FLyrVect() {

        super();

    }

    /**

     * Devuelve el VectorialAdapater de la capa.

     * 

     * @return VectorialAdapter.

     */

    public DataStore getDataStore() {

        if (!this.isAvailable()) {

            return null;

        }

        return featureStore;

    }

//    public void setCoordTrans(ICoordTrans ct) {

//            super.setCoordTrans(ct);

//            if (ct != null){

//                    if (this.reprojectTransform == null){

//                            this.reprojectTransform = new ReprojectDefaultGeometry(ct);

//                    } else {

//                            this.reprojectTransform.setCoordTrans(ct);

//                    }

//                    try {

//                            this.getFeatureStore().getTransforms().add(this.reprojectTransform);

//                    } catch (DataException e) {

//                            throw new RuntimeException(e);

//                    }

//            }

//    }

    /**

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

    // }

    //

    // }

    /**

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

     * 

     * @deprecated esto deber?a se ser protected

     */

    public void setDataStore(DataStore dataStore) throws LoadLayerException {

        if (this.featureStore != null && this.featureStore != dataStore) {

            this.featureStore.deleteObserver(this);

        }

        featureStore = (FeatureStore) dataStore;

        IVectorLegend legend =

            (IVectorLegend) MapContextLocator.getMapContextManager().getLegend(dataStore);

        if (legend == null) {

            throw new LegendLayerException(this.getName());

        }

        this.setLegend(legend);

        ILabelingStrategy labeler = null;

        try {

            labeler =

                (ILabelingStrategy) dataStore.invokeDynMethod("getLabeling",

                    null);

        } catch (DynMethodNotSupportedException e1) {

            labeler = null;

        } catch (DynMethodException e1) {

            logger.error("Can't load the specific lebeling strategy provided for the layer {}.",

                this.getName(),

                e1);

        }

        if (labeler != null) {

            labeler.setLayer(this);

            this.setLabelingStrategy(labeler);

            this.setIsLabeled(true); // TODO: ac? no s'hauria de detectar si t?

            // etiquetes?????

        }

        this.delegate(dataStore);

        dataStore.addObserver(this);

        ToolsLocator.getDisposableManager().bind(dataStore);

    }

    public Envelope getFullEnvelope() throws ReadException {

        Envelope rAux;

        try {

            rAux = getFeatureStore().getEnvelope();

        } catch (BaseException e) {

            throw new ReadException(getName(), e);

        }

        // Esto es para cuando se crea una capa nueva con el fullExtent de ancho

        // y alto 0.

        if (rAux == null || rAux.isEmpty() || rAux.getMaximum(0) - rAux.getMinimum(0) == 0

            && rAux.getMaximum(1) - rAux.getMinimum(1) == 0) {

            try {

                rAux =

                    geomManager.createEnvelope(0, 0, 90, 90, SUBTYPES.GEOM2D);

            } catch (CreateEnvelopeException e) {

                logger.error("Error creating the envelope", e);

                e.printStackTrace();

            }

        }

        // Si existe reproyecci?n, reproyectar el extent

        ICoordTrans ct = getCoordTrans();

        try {

            if (ct != null) {

                Point2D pt1 =

                    new Point2D.Double(rAux.getMinimum(0), rAux.getMinimum(1));

                Point2D pt2 =

                    new Point2D.Double(rAux.getMaximum(0), rAux.getMaximum(1));

                pt1 = ct.convert(pt1, null);

                pt2 = ct.convert(pt2, null);

                try {

                    rAux =

                        geomManager.createEnvelope(pt1.getX(),

                            pt1.getY(),

                            pt2.getX(),

                            pt2.getY(),

                            SUBTYPES.GEOM2D);

                } catch (CreateEnvelopeException e) {

                    logger.error("Error creating the envelope", e);

                    e.printStackTrace();

                }// new Rectangle2D.Double();

            }

        } catch (IllegalStateException e) {

            this.setAvailable(false);

            this.addError(new ReprojectLayerException(getName(), e));

        }

        return rAux;

    }

    /**

     * Draws using IFeatureIterator. This method will replace the old draw(...)

     * one.

     * 

     * @autor jaume dominguez faus - jaume.dominguez@iver.es

     * @param image

     * @param g

     * @param viewPort

     * @param cancel

     * @param scale

     * @throws ReadDriverException

     */

    public void draw(BufferedImage image,

        Graphics2D g,

        ViewPort viewPort,

        Cancellable cancel,

        double scale) throws ReadException {

        if (legend == null) {

            return;

        }

        if (!this.isWithinScale(scale)) {

            return;

        }

        if (cancel.isCanceled()) {

            return;

        }

        if (spatialCache.isEnabled()) {

            spatialCache.clearAll();

            legend.addDrawingObserver(this);

        }

        FeatureQuery featureQuery = null;

        try {

            FeatureAttributeDescriptor featureAttributeDescriptor =

                getFeatureStore().getDefaultFeatureType().getDefaultTimeAttribute();

            if ((viewPort.getTime() != null) && (featureAttributeDescriptor != null)){

                featureQuery = getFeatureStore().createFeatureQuery();

                IntersectsTimeEvaluator intersectsTimeEvaluator =

                    new IntersectsTimeEvaluator(viewPort.getTime(), featureAttributeDescriptor.getName());

                featureQuery.addFilter(intersectsTimeEvaluator);

            }

        } catch (DataException e1) {

            logger.error("Impossible to get the temporal filter", e1);

        }

        try {

            legend.draw(image,

                g,

                viewPort,

                cancel,

                scale,

                null,

                getCoordTrans(),

                getFeatureStore(),

                featureQuery);

        } catch (LegendException e) {

            this.setVisible(false);

            this.setActive(false);

            throw new ReadException(getName(), e);

        } finally {

            if (spatialCache.isEnabled()) {

                legend.deleteDrawingObserver(this);

            }

        }

    }

    public void print(Graphics2D g,

        ViewPort viewPort,

        Cancellable cancel,

        double scale,

        PrintAttributes properties) throws ReadException {

        if (!this.isWithinScale(scale)) {

            return;

        }

        if (cancel.isCanceled()) {

            return;

        }

        try {

            legend.print(g,

                viewPort,

                cancel,

                scale,

                null,

                getCoordTrans(),

                getFeatureStore(),

                null,

                properties);

        } catch (LegendException e) {

            this.setVisible(false);

            this.setActive(false);

            throw new ReadException(getName(), e);

        }

    }

    /**

     * <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 (ReadException 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 (ReadException e) {

    // // TODO Auto-generated catch block

    // e.printStackTrace();

    // }

    // }

    // public void createSpatialIndex() {

    // createSpatialIndex(null);

    // }

    public void setLegend(IVectorLegend legend) throws LegendLayerException {

        if (this.legend == legend) {

            return;

        }

        if (this.legend != null && this.legend.equals(legend)) {

            return;

        }

        IVectorLegend oldLegend = this.legend;

        this.legend = legend;

        if (oldLegend != null) {

            oldLegend.removeLegendListener(this);

            oldLegend.deleteDrawingObserver(this);

        }

        if (legend != null) {

            this.legend.addDrawingObserver(this);

            this.legend.addLegendListener(this);

        }

        LegendChangedEvent e =

            LegendChangedEvent.createLegendChangedEvent(oldLegend, this.legend);

        e.setLayer(this);

        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 ReadException

     */

    public int getShapeType() throws ReadException {

            if (typeShape == -1) {

                    FeatureType featureType = null;

                    try {

                            if( getDataStore()!=null ){

                                    featureType =

                                            (((FeatureStore) getDataStore()).getDefaultFeatureType());

                            }

                    } catch (DataException e) {

                            throw new ReadException(getName(), e);

                    }

                    if( featureType!=null ){

                            int indexGeom = featureType.getDefaultGeometryAttributeIndex();

                            typeShape =

                                    featureType.getAttributeDescriptor(indexGeom).getGeometryType();

                    }

            }

            return typeShape;

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        if (!this.isAvailable()) {

            return;

        }

        super.saveToState(state);

        if (getLegend() != null) {

            state.set("legend", getLegend());

        }

        FeatureStore fst = null;

        fst = getFeatureStore();

        if (fst != null) {

            state.set("featureStore", fst);

        }

        state.set("isLabeled", isLabeled);

        if (strategy != null) {

            state.set("labelingStrategy", strategy);

        }

        if (getLinkProperties() != null) {

            state.set("linkProperties", getLinkProperties());

        }

        // state.set("bHasJoin", bHasJoin);

        state.set("typeShape", typeShape);

    }

    // public XMLEntity getXMLEntity() throws XMLException {

    //

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

    // return this.orgXMLEntity;

    // }

    // XMLEntity xml = super.getXMLEntity();

    // if (getLegend()!=null){

    // XMLEntity xmlLegend=getLegend().getXMLEntity();

    // xmlLegend.putProperty("tagName","legend");

    // xml.addChild(xmlLegend);

    // }

    // try {

    // PersistenceManager manager = ToolsLocator.getPersistenceManager();

    // PersistentState stateFeatureStore=manager.getState(getFeatureStore());

    // stateFeatureStore.set("tagName","featureStore");

    // xml.addChild(((XMLEntityState)stateFeatureStore).getXMLEntity());

    // } catch (ReadException e) {

    // throw new XMLLayerException(getName(),e);

    // } catch (PersistenceException e) {

    // throw new XMLLayerException(getName(),e);

    // }

    // // properties from ILabelable

    // xml.putProperty("isLabeled", isLabeled);

    // if (strategy != null) {

    // XMLEntity strategyXML = strategy.getXMLEntity();

    // strategyXML.putProperty("tagName", "labelingStrategy");

    // xml.addChild(strategy.getXMLEntity());

    // }

    // xml.addChild(getLinkProperties().getXMLEntity());

    // return xml;

    // }

    public void loadFromState(PersistentState state) throws PersistenceException {

        super.loadFromState(state);

        DataStore store = null;

        try {

                store = (DataStore) state.get("featureStore");

        } catch (PersistenceRuntimeException e) {

                        this.setAvailable(false);

                        return;

                }

        try {

            this.setDataStore(store);

        } catch (LoadLayerException e) {

            throw new PersistenceException("While loading FLyrVect from state.",

                e);

        }

        IVectorLegend lgnd = (IVectorLegend) state.get("legend");

        try {

            this.setLegend(lgnd);

        } catch (LegendLayerException e) {

            throw new PersistenceException("While loading FLyrVect from state.",

                e);

        }

        Boolean isLbl = new Boolean(false);

        ILabelingStrategy lblst = null;

        try {

            isLbl = (Boolean) state.get("isLabeled");

            if (isLbl.booleanValue()) {

                lblst = (ILabelingStrategy) state.get("labelingStrategy");

            }

        } catch (Exception ex) {

            throw new PersistenceException("While loading FLyrVect from state.",

                ex);

        }

        /*

         * String _labelFieldName = null;

         * String _labelfield = null;

         */

        if (isLbl.booleanValue()) {

            this.setIsLabeled(true);

            this.setLabelingStrategy(lblst);

        } else {

            this.setIsLabeled(false);

            this.setLabelingStrategy(null);

        }

        // try {

        // linkProperties = (FLyrVectLinkProperties)

        // state.get("linkProperties");

        // } catch (PersistenceException pex) {

        // // not mandatory

        // linkProperties = null;

        // }

        // bHasJoin = state.getBoolean("bHasJoin");

        typeShape = state.getInt("typeShape");

        // try { _labelFieldName = state.getString("labelFieldName"); } catch

        // (PersistenceException ex) {

        // _labelFieldName = null;

        // }

        // try { _labelfield = state.getString("labelfield"); } catch

        // (PersistenceException ex) {

        // _labelfield = null;

        // }

        // ILabelingStrategy not implemented

        // if (_labelFieldName != null) {

        //

        // AttrInTableLabelingStrategy labeling = new

        // AttrInTableLabelingStrategy();

        // try {

        // labeling.setLayer(this);

        // } catch (ReadException e) {

        // logger.error("While setting layer to AttrInTableLabelingStrategy: " +

        // e.getMessage());

        // }

        // labeling.setUsesFixedSize(true);

        // labeling.setFixedSize(10);

        // labeling.setTextField(_labelFieldName);

        // labeling.setHeightField(state.getString("labelHeightFieldName"));

        // labeling.setRotationField(state.getString("labelRotationFieldName"));

        // setLabelingStrategy(labeling);

        // setIsLabeled(true);

        //

        // } else {

        // if (_labelfield != null) {

        //

        // AttrInTableLabelingStrategy labeling = new

        // AttrInTableLabelingStrategy();

        // try {

        // labeling.setLayer(this);

        // } catch (ReadException e) {

        // logger.error("While setting layer to AttrInTableLabelingStrategy: " +

        // e.getMessage());

        // }

        // labeling.setUsesFixedSize(true);

        // labeling.setFixedSize(10);

        // labeling.setTextField(_labelfield);

        // labeling.setHeightField(state.getString("labelFieldHeight"));

        // labeling.setRotationField(state.getString("labelFieldRotation"));

        // setLabelingStrategy(labeling);

        // setIsLabeled(true);

        // }

        // }

    }

    // public void setXMLEntity(XMLEntity xml) throws XMLException {

    // try {

    // super.setXMLEntity(xml);

    // XMLEntity legendXML = xml.firstChild("tagName","legend");

    // IVectorLegend leg = LegendFactory.createFromXML(legendXML);

    //

    // // PersistentState persistentState=new XMLEntityState(new

    // XMLEntityManager());

    // XMLEntity xmlStore=xml.firstChild("tagName","featureStore");

    // XMLEntityManager xmlManger = new XMLEntityManager();

    // PersistentState state = xmlManger.createState(xmlStore);

    // DataStore store = (DataStore)

    // ToolsLocator.getPersistenceManager().create(state);

    // // persistentState.createState(xmlStore);

    //

    // // DataManager dm=DALLocator.getDataManager();

    //

    // this.setDataStore(store);

    // /* end patch */

    // try {

    // setLegend(leg);

    // } catch (LegendLayerException e) {

    // throw new XMLLegendException(e);

    // }

    // // set properties for ILabelable

    //

    // if (xml.contains("isLabeled")

    // && xml.getBooleanProperty(("isLabeled"))) {

    // XMLEntity labelingXML = xml.firstChild("tagName", "labelingStrategy");

    // if (labelingXML != null){

    //

    // isLabeled = true;

    // try {

    // this.strategy = LabelingFactory.createStrategyFromXML(labelingXML, this);

    // } catch (NotExistInXMLEntity neXMLEX) {

    // // no strategy was set, just continue;

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

    // }

    // } else {

    // isLabeled = false;

    // }

    // } else if (legendXML.contains("labelFieldName")||

    // legendXML.contains("labelfield")) {

    // /* (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.

    // */

    // String labelTextField = null;

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

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

    // if (labelTextField != null) {

    // AttrInTableLabelingStrategy labeling = new AttrInTableLabelingStrategy();

    // labeling.setLayer(this);

    // labeling.setUsesFixedSize(true);

    // labeling.setFixedSize(10);

    // labeling.setTextField(labelTextField);

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

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

    // this.setLabelingStrategy(labeling);

    // this.setIsLabeled(true);

    // }

    // }else{

    // labelTextField = legendXML.getStringProperty("labelfield");

    // if (labelTextField != null) {

    // AttrInTableLabelingStrategy labeling = new AttrInTableLabelingStrategy();

    // labeling.setLayer(this);

    // labeling.setUsesFixedSize(true);

    // labeling.setFixedSize(10);

    // labeling.setTextField(labelTextField);

    // labeling.setHeightField(legendXML.getStringProperty("labelFieldHeight"));

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

    // this.setLabelingStrategy(labeling);

    // this.setIsLabeled(true);

    // }

    // }

    // }else{

    // isLabeled = false;

    // }

    // XMLEntity xmlLinkProperties=xml.firstChild("typeChild","linkProperties");

    // if (xmlLinkProperties != null){

    // getLinkProperties().setXMLEntity(xmlLinkProperties);

    // }

    // } catch (Exception e) {

    // e.printStackTrace();

    // this.setAvailable(false);

    // this.orgXMLEntity = xml;

    //

    // }

    // //

    //

    // }

    /**

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

     * @throws StopEditionLayerException 

     */

    // 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 void setEditing(boolean b) throws StartEditionLayerException {

        super.setEditing(b);

        FeatureStore fs = getFeatureStore();

        if (b) {

            try {

                fs.edit();

            } catch (ReadException e) {

                throw new StartEditionLayerException(getName(), e);

            } catch (DataException e) {

                throw new StartEditionLayerException(getName(), e);

            }

        }

        setSpatialCacheEnabled(b);

        callEditionChanged(LayerEvent.createEditionChangedEvent(this, "edition"));

    }

    /**

     * @deprecated Use {@link #getSpatialCache()}

     */

    public void clearSpatialCache() {

        spatialCache.clearAll();

    }

    /**

     * @deprecated Use {@link #getSpatialCache()}

     */

    public boolean isSpatialCacheEnabled() {

        return spatialCache.isEnabled();

    }

    /**

     * @deprecated Use {@link #getSpatialCache()}

     */

    public void setSpatialCacheEnabled(boolean spatialCacheEnabled) {

        spatialCache.setEnabled(spatialCacheEnabled);

    }

    public SpatialCache getSpatialCache() {

        return spatialCache;

    }

    /**

     * Siempre es un numero mayor de 1000

     * 

     * @param maxFeatures

     */

    public void setMaxFeaturesInEditionCache(int maxFeatures) {

        if (maxFeatures > spatialCache.getMaxFeatures()) {

            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 {

        super.reload();

        try {

            getFeatureStore().refresh();

        } catch (Exception e) {

            throw new ReloadLayerException(getName(), e);

        }

    }

    protected void setLoadSelection(Object xml) {

        // this.loadSelection = xml;

    }

    protected void setLoadLegend(IVectorLegend legend) {

        this.loadLegend = legend;

    }

    protected void putLoadSelection() {

        // 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;

    }

    public boolean isWritable() {

        return getFeatureStore().allowWrite();

    }

    public FLayer cloneLayer() throws Exception {

        FLyrVect clonedLayer = new FLyrVect();

        clonedLayer.setDataStore(getDataStore());

        // if (isJoined()) {

        // clonedLayer.setIsJoined(true);

        // }

        clonedLayer.setVisible(isVisible());

        // clonedLayer.setISpatialIndex(getISpatialIndex());

        clonedLayer.setName(getName());

        clonedLayer.setCoordTrans(getCoordTrans());

        clonedLayer.setLegend((IVectorLegend) getLegend().cloneLegend());

        clonedLayer.setIsLabeled(isLabeled());

        ILabelingStrategy labelingStrategy = getLabelingStrategy();

        if (labelingStrategy != null) {

            clonedLayer.setLabelingStrategy(labelingStrategy);

        }

        return clonedLayer;

    }

    protected boolean isOnePoint(AffineTransform graphicsTransform,

        ViewPort viewPort,

        double dpi,

        CartographicSupport csSym,

        Geometry geom,

        int[] xyCoords) {

        return isOnePoint(graphicsTransform, viewPort, geom, xyCoords)

        && csSym.getCartographicSize(viewPort, dpi, geom) <= 1;

    }

    private boolean isOnePoint(AffineTransform graphicsTransform,

        ViewPort viewPort,

        Geometry geom,

        int[] xyCoords) {

        boolean onePoint = false;

        int type = geom.getType();

        if (type == Geometry.TYPES.NULL) {

            return false;

        }

        if (type != Geometry.TYPES.POINT && type != Geometry.TYPES.MULTIPOINT) {

            Envelope geomBounds = geom.getEnvelope();

            // ICoordTrans ct = getCoordTrans();

            // Se supone que la geometria ya esta reproyectada

            // if (ct!=null) {

            // // geomBounds = ct.getInverted().convert(geomBounds);

            // geomBounds = geomBounds.convert(ct);

            // }

            double dist1Pixel = viewPort.getDist1pixel();

            onePoint =

                (geomBounds.getLength(0) <= dist1Pixel && geomBounds.getLength(1) <= dist1Pixel);

            if (onePoint) {

                // avoid out of range exceptions

                org.gvsig.fmap.geom.primitive.Point p;

                try {

                    p =

                        geomManager.createPoint(geomBounds.getMinimum(0),

                            geomBounds.getMinimum(1),

                            SUBTYPES.GEOM2D);

                    p.transform(viewPort.getAffineTransform());

                    p.transform(graphicsTransform);

                    xyCoords[0] = (int) p.getX();

                    xyCoords[1] = (int) p.getY();

                } catch (org.gvsig.fmap.geom.exception.CreateGeometryException e) {

                    logger.error("Error creating a point", e);

                }

            }

        }

        return onePoint;

    }

    /*

     * jaume. Stuff from ILabeled.

     */

    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;

        if (strategy == null) {

            return;

        }

        strategy.setLayer(this);

    }

    public void drawLabels(BufferedImage image,

        Graphics2D g,

        ViewPort viewPort,

        Cancellable cancel,

        double scale,

        double dpi) throws ReadException {

        if (strategy != null && isWithinScale(scale)) {

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

        }

    }

    public void printLabels(Graphics2D g,

        ViewPort viewPort,

        Cancellable cancel,

        double scale,

        PrintAttributes properties) throws ReadException {

        if (strategy != null) {

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

        }

    }

    // M?todos para el uso de HyperLinks en capas FLyerVect

    /**

     * Return true, because a Vectorial Layer supports HyperLink

     */

    public boolean allowLinks() {

        return true;

    }

    /**

     * Returns an instance of AbstractLinkProperties that contains the

     * information

     * of the HyperLink

     * 

     * @return Abstra

     */

    // public AbstractLinkProperties getLinkProperties()

    // {

    // return linkProperties;

    // }

    /**

     * Provides an array with URIs. Returns one URI by geometry that includes

     * the point

     * in its own geometry limits with a allowed tolerance.

     * 

     * @param layer

     *            , the layer

     * @param point

     *            , the point to check that is contained or not in the

     *            geometries in the layer

     * @param tolerance

     *            , the tolerance allowed. Allowed margin of error to detect if

     *            the point

     *            is contained in some geometries of the layer

     * @return

     * @throws ReadException

     * @throws BehaviorException

     */

    // public URI[] getLink(Point2D point, double tolerance) throws

    // ReadException

    // {

    // //return linkProperties.getLink(this)

    // return linkProperties.getLink(this,point,tolerance);

    // }

    public void load() throws LoadLayerException {

        super.load();

    }

    public FeatureStore getFeatureStore() {

        return (FeatureStore) getDataStore();

    }

    /**

     * @deprecated use instead {@link #queryByPoint(org.gvsig.fmap.geom.primitive.Point, double, FeatureType)}

     */

    public FeatureSet queryByPoint(Point2D mapPoint,

        double tol,

        FeatureType featureType) throws DataException {

        logger.warn("Deprecated use of queryByPoint.");

        GeometryManager manager = GeometryLocator.getGeometryManager();

        org.gvsig.fmap.geom.primitive.Point center;

        try {

            center =

                (org.gvsig.fmap.geom.primitive.Point) manager.create(TYPES.POINT,

                    SUBTYPES.GEOM2D);

            center.setX(mapPoint.getX());

            center.setY(mapPoint.getY());

            Circle circle =

                (Circle) manager.create(TYPES.CIRCLE, SUBTYPES.GEOM2D);

            circle.setPoints(center, tol);

            return queryByGeometry(circle, featureType);

        } catch (org.gvsig.fmap.geom.exception.CreateGeometryException e) {

            throw new CreateGeometryException(TYPES.CIRCLE, SUBTYPES.GEOM2D, e);

        }

    }

    public FeatureSet queryByPoint(org.gvsig.fmap.geom.primitive.Point point,

        double tol,

        FeatureType featureType) throws DataException {

        GeometryManager manager = GeometryLocator.getGeometryManager();

        try {

            Circle circle =

                (Circle) manager.create(TYPES.CIRCLE, SUBTYPES.GEOM2D);

            circle.setPoints(point, tol);

            return queryByGeometry(circle, featureType);

        } catch (org.gvsig.fmap.geom.exception.CreateGeometryException e) {

            throw new CreateGeometryException(TYPES.CIRCLE, SUBTYPES.GEOM2D, e);

        }

    }

    public FeatureSet queryByGeometry(Geometry geom, FeatureType featureType) throws DataException {

        FeatureQuery featureQuery = featureStore.createFeatureQuery();

        String geomName =

            featureStore.getDefaultFeatureType()

            .getDefaultGeometryAttributeName();

        featureQuery.setFeatureType(featureType);

        IntersectsGeometryEvaluator iee =

            new IntersectsGeometryEvaluator(geom,

                getMapContext().getViewPort().getProjection(),

                featureStore.getDefaultFeatureType(),

                geomName);

        featureQuery.setFilter(iee);

        return getFeatureStore().getFeatureSet(featureQuery);

    }

    /**

     * It return the {@link FeatureSet} that intersects with the envelope.

     * @param envelope

     *          envelope that defines the area for the query.

     * @param featureType

     *          only the features with this feature type are used in

     *          the query.    

     * @return

     *          the set of features that intersect with the envelope.

     * @throws DataException

     */

    public FeatureSet queryByEnvelope(Envelope envelope, FeatureType featureType) throws DataException {

        return queryByEnvelope(envelope, featureType, null);

    }

    /**

     * It return the {@link FeatureSet} that intersects with the envelope.

     * @param envelope