| 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.Color;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.net.URI;

import java.util.ArrayList;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.PrintQuality;

import org.apache.log4j.Logger;

import org.cresques.cts.ICoordTrans;

import com.hardcode.driverManager.Driver;

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.hardcode.gdbms.engine.instruction.SemanticException;

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

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

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

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.MapContext;

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

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

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

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

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

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.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.core.v02.FSymbol;

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.IVectorialJDBCDriver;

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.IClassifiedVectorLegend;

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

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

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.IPersistence;

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());

    /**

     * @deprecated Don?t use Strategy, you should be use iterators.

     */

    public static boolean forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD = true;

    /**

     * @deprecated Don?t use Strategy, you should be use iterators.

     */

    private boolean useStrategy=false;

    /** Leyenda de la capa vectorial */

    private IVectorLegend legend;

    private int typeShape = -1;

    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 IVectorLegend loadLegend = null;

    //Lo a?ado. Caracter?sticas de HyperEnlace (LINK)

    private FLyrVectLinkProperties linkProperties=new FLyrVectLinkProperties();

    //private ArrayList linkProperties=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;

        }

    }

    /**

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

    }

    /**

     * 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 ReadDriverException {

            boolean bDrawShapes = true;

            if (legend instanceof SingleSymbolLegend) {

                    bDrawShapes = legend.getDefaultSymbol().isShapeVisible();

            }

            Point2D offset = viewPort.getOffset();

            double dpi = MapContext.getScreenDPI();

            if (bDrawShapes) {

                    boolean cacheFeatures = isSpatialCacheEnabled();

                    SpatialCache cache = null;

                if (cacheFeatures) {

                        getSpatialCache().clearAll();

                        cache = getSpatialCache();

                }

                    try {

                            prepareDrawing(image, g, viewPort);

                            ArrayList<String> fieldList = new ArrayList<String>();

                            // fields from legend

                            String[] aux = null;

                            if (legend instanceof IClassifiedVectorLegend) {

                                    aux = ((IClassifiedVectorLegend) legend).getClassifyingFieldNames();

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

                                            fieldList.add(aux[i]);

                                    }

                            }

                            // fields from labeling

                            if (getLabelingStrategy()!=null && isLabeled()) {

                                    aux = getLabelingStrategy().getUsedFields();

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

                                            fieldList.add(aux[i]);

                                    }

                            }

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

                            // if layer has map levels it will use a ZSort

                            boolean useZSort = zSort != null && zSort.isUsingZSort();

                            // -- visual FX stuff

                            long time = System.currentTimeMillis();

                            BufferedImage virtualBim;

                            Graphics2D virtualGraphics;

                            // render temporary map each screenRefreshRate milliseconds;

                            int screenRefreshDelay = (int) ((1D/MapControl.getDrawFrameRate())*3*1000);

                            BufferedImage[] imageLevels = null;

                            Graphics2D[] graphics = null;

                            if (useZSort) {

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

                                    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();

                                            graphics[i].setTransform(g.getTransform());

                                    }

                            }

                            // -- end visual FX stuff

                            // Get the iterator over the visible features

                            IFeatureIterator it = getSource().getFeatureIterator(

                                            viewPort.getAdjustedExtent(),

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

                                            viewPort.getProjection(),

                                            true);

                            // Iteration over each feature

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

                                    IFeature feat = it.next();

                                    IGeometry geom = feat.getGeometry();

                                    if (cacheFeatures) {

                                            if (cache.getMaxFeatures() >= cache.size()) {

                                                        // already reprojected

                                                        cache.insert(geom.getBounds2D(), geom);

                                                }

                                    }

                                    // retrieve the symbol associated to such feature

                                    ISymbol sym = legend.getSymbolByFeature(feat);

                                    //C?digo para poder acceder a los ?ndices para ver si est? seleccionado un Feature

                                    ReadableVectorial rv=getSource();

                                    int selectionIndex=-1;

                                    if (rv instanceof ISpatialDB){

                                            selectionIndex=((ISpatialDB)rv).getRowIndexByFID(feat);

                                    }else{

                                            selectionIndex=Integer.parseInt(feat.getID());

                                    }

                                    if (selectionIndex!=-1) {

                                            if (selectionSupport.isSelected(selectionIndex)) {

                                                sym = sym.getSymbolForSelection();

                                        }

                                }

                                    // Check if this symbol is sized with CartographicSupport

                                    CartographicSupport csSym = null;

                                    int symbolType = sym.getSymbolType();

                                    boolean bDrawCartographicSupport = false;

                                    if (   symbolType == FShape.POINT

                                                    || symbolType == FShape.LINE

                                                    || sym instanceof CartographicSupport) {

//                                             patch

                                        if (!sym.getClass().equals(FSymbol.class)) {

                                                csSym = (CartographicSupport) sym;

                                                bDrawCartographicSupport = (csSym.getUnit() != -1);

                                        }

                                    }

                                    int x = -1;

                                    int y = -1;

                                    int[] xyCoords = new int[2];

                                    // Check if size is a pixel

                                    boolean onePoint = bDrawCartographicSupport ?

                                                    isOnePoint(g.getTransform(), viewPort, MapContext.getScreenDPI(), csSym, geom, xyCoords) :

                                                    isOnePoint(g.getTransform(), viewPort, geom, xyCoords);

                                        // Avoid out of bounds exceptions

                                        if (onePoint) {

                                                x = xyCoords[0];

                                                y = xyCoords[1];

                                                if (x<0 || y<0 || x>= viewPort.getImageWidth() || y>=viewPort.getImageHeight()) continue;

                                        }

                                        if (useZSort) {

                                                // Check if this symbol is a multilayer

                                                if (sym instanceof IMultiLayerSymbol) {

                                                        // if so, treat each of its layers as a single symbol

                                                        // in its corresponding map level

                                                        IMultiLayerSymbol mlSym = (IMultiLayerSymbol) sym;

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

                                                                ISymbol mySym = mlSym.getLayer(i);

                                                                if (onePoint) {

                                                                        if (x<0 || y<0 || x>= imageLevels[zSort.getSymbolLevel(mySym)].getWidth() || y>=imageLevels[zSort.getSymbolLevel(mySym)].getHeight()) continue;

                                                                        imageLevels[zSort.getSymbolLevel(mySym)].setRGB(x, y, mySym.getOnePointRgb());

                                                                } else {

                                                                        if (!bDrawCartographicSupport) {

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

                                                                        } else {

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

                                                                        }

                                                                }

                                                        }

                                                } else {

                                                        // else, just draw the symbol in its level

                                                        if (!bDrawCartographicSupport) {

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

                                                        } else {

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

                                                        }

                                                }

                                                // -- visual FX stuff

                                                // Cuando el offset!=0 se est? dibujando sobre el Layout y por tanto no tiene que ejecutar el siguiente c?digo.

                                                if (offset.getX()==0 && offset.getY()==0)

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

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

                                                                time = System.currentTimeMillis();

                                                        }

                                                // -- end visual FX stuff

                                        } else {

                                                // no ZSort, so there is only a map level, symbols are

                                                // just drawn.

                                                if (onePoint) {

                                                        if (x<0 || y<0 || x>= image.getWidth() || y>=image.getHeight()) continue;

                                                        image.setRGB(x, y, sym.getOnePointRgb());

                                                } else {

                                                        if (!bDrawCartographicSupport) {

                                                                geom.drawInts(g, viewPort, sym, cancel);

                                                        } else {

                                                                geom.drawInts(g, viewPort, dpi, csSym);

                                                        }

                                                }

                                        }

                            }

                            if (useZSort) {

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

                                        g.translate(offset.getX(), offset.getY());

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

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

                                            imageLevels[i] = null;

                                            graphics[i] = null;

                                    }

                                        g.translate(-offset.getX(), -offset.getY());

                                    imageLevels = null;

                                    graphics = null;

                            }

                            it.closeIterator();

                    } catch (ReadDriverException e) {

                            this.setVisible(false);

                            this.setActive(false);

                            throw e;

                    }

            }

    }

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

            Cancellable cancel, double scale) throws ReadDriverException {

//            forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD = true;

            if (!isUseStrategy()) {

                    _draw(image, g, viewPort, cancel, scale);

            } else {

//                    moved up to FLayers

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

            boolean bDrawShapes = true;

            if (legend instanceof SingleSymbolLegend) {

                    bDrawShapes = legend.getDefaultSymbol().isShapeVisible();

            }

            if (bDrawShapes) {

                    double dpi = 72;

                    PrintQuality resolution=(PrintQuality)properties.get(PrintQuality.class);

                    if (resolution.equals(PrintQuality.NORMAL)){

                            dpi = 300;

                    } else if (resolution.equals(PrintQuality.HIGH)){

                            dpi = 600;

                    } else if (resolution.equals(PrintQuality.DRAFT)){

                            dpi = 72;

                    }

                    try {

                            prepareDrawing(null, g, viewPort);

                            ArrayList<String> fieldList = new ArrayList<String>();

                            String[] aux;

                            // fields from legend

                            if (legend instanceof IClassifiedVectorLegend) {

                                    aux = ((IClassifiedVectorLegend) legend).

                                                                            getClassifyingFieldNames();

                                    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]);

                                    }

                            }

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

                            // if layer has map levels it will use a ZSort

                            boolean useZSort = zSort != null && zSort.isUsingZSort();

                            int mapLevelCount = (useZSort) ? zSort.getLevelCount() : 1;

                            for (int mapPass = 0; mapPass < mapLevelCount; mapPass++) {

                                    // Get the iterator over the visible features

                                    IFeatureIterator it = getSource().getFeatureIterator(

                                                    viewPort.getAdjustedExtent(),

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

                                                    viewPort.getProjection(),

                                                    true);

                                    // Iteration over each feature

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

                                            IFeature feat = it.next();

                                            IGeometry geom = feat.getGeometry();

                                            // retreive the symbol associated to such feature

                                            ISymbol sym = legend.getSymbolByFeature(feat);

                                            if (useZSort) {

                                                    // Check if this symbol is a multilayer

                                                        if (sym instanceof IMultiLayerSymbol) {

                                                                // if so, get the layer corresponding to the current

                                                                // level. If none, continue to next iteration

                                                                IMultiLayerSymbol mlSym = (IMultiLayerSymbol) sym;

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

                                                                        ISymbol mySym = mlSym.getLayer(i);

                                                                        if (zSort.getSymbolLevel(mySym) == mapPass) {

                                                                                sym = mySym;

                                                                                break;

                                                                        }

                                                                        System.out.println("avoided layer "+i+"of symbol '"+mlSym.getDescription()+"' (pass "+mapPass+")");

                                                                }

                                                                if (sym == null) {

                                                                        continue;

                                                                }

                                                        } else {

                                                                // else, just draw the symbol in its level

                                                                if (zSort.getSymbolLevel(sym) != mapPass) {

                                                                        System.out.println("avoided single layer symbol '"+sym.getDescription()+"' (pass "+mapPass+")");

                                                                        continue;

                                                                }

                                                        }

                                            }

                                            // Check if this symbol is sized with CartographicSupport

                                            CartographicSupport csSym = null;

                                            int symbolType = sym.getSymbolType();

                                            boolean bDrawCartographicSupport = false;

                                            if (   symbolType == FShape.POINT

                                                            || symbolType == FShape.LINE

                                                            || sym instanceof CartographicSupport) {

                                                    csSym = (CartographicSupport) sym;

                                                    bDrawCartographicSupport = (csSym.getUnit() != -1);

                                            }

                                            System.err.println("passada "+mapPass+" pinte s?mboll "+sym.getDescription());

                                            if (!bDrawCartographicSupport) {

                                                    geom.drawInts(g, viewPort, sym, null);

                                            } else {

                                                    geom.drawInts(g, viewPort, dpi, (CartographicSupport) csSym);

                                            }

                                    }

                                    it.closeIterator();

                            }

                    } catch (ReadDriverException e) {

                            this.setVisible(false);

                            this.setActive(false);

                            throw e;

                    }

            }

    }

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

            double scale, PrintRequestAttributeSet properties) throws ReadDriverException {

            if (forTestOnlyVariableUseIterators_REMOVE_THIS_FIELD) {

                    _print(g, viewPort, cancel, scale, properties);

            } else {

//                    moved up to Flayers

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

        }

    }

    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(IVectorLegend r) throws LegendLayerException {

        IVectorLegend 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 IPersistence) {

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

                    IPersistence persist = (IPersistence) 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());

        }

        xml.addChild(getLinkProperties().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);

            IVectorLegend 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");

                }

            }

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

            if (xmlLinkProperties != null){

                     getLinkProperties().setXMLEntity(xmlLinkProperties);

            }

        } 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);

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

        }

    }

    /**

     * 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.setCoordTrans(getCoordTrans());

                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