| gvSIG desktop 1

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

 *

 * Copyright (C) 2005 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.Font;

import java.awt.Graphics2D;

import java.awt.Shape;

import java.awt.font.FontRenderContext;

import java.awt.font.GlyphVector;

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 javax.print.attribute.PrintRequestAttributeSet;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import com.hardcode.driverManager.Driver;

import com.hardcode.driverManager.DriverLoadException;

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

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

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

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

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.andami.messages.NotificationManager;

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

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

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

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

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

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

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

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

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

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

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

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

import com.iver.cit.gvsig.fmap.crs.CRSFactory;

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

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

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

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

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

import com.iver.cit.gvsig.fmap.operation.strategies.Annotation_Strategy;

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

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

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

import com.iver.utiles.XMLEntity;

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

/**

 * Annotation's layer.

 *

 * @author Vicente Caballero Navarro

 */

public class Annotation_Layer extends FLyrVect {

    private Annotation_Mapping mapping = null;

    private int indexEditing = -1;

    private Annotation_Legend aLegend;

    private Strategy strategy = null;

    private final static AffineTransform ati=new AffineTransform();

    /**

     * Crea un nuevo FLyrAnnotation.

     */

    public Annotation_Layer() {

        super();

    }

    /**

     * DOCUMENT ME!

     *

     * @param mapping DOCUMENT ME!

     * @throws ReadDriverException

     * @throws LegendLayerException

     * @throws DriverException

     * @throws FieldNotFoundException

     */

    public void setMapping(Annotation_Mapping mapping) throws LegendLayerException, ReadDriverException {

        this.mapping = mapping;

        aLegend = new Annotation_Legend();

        setLegend();

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public Annotation_Mapping getAnnotatonMapping() {

        return mapping;

    }

    /**

     * @throws ReadDriverException

     * @throws InitializeDriverException

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

     *      java.awt.Graphics2D, ISymbol)

     */

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

        Cancellable cancel, double scale) throws InitializeDriverException, ReadDriverException {

        if (isWithinScale(scale)) {

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

            // no pasamos por ellas

            boolean bDrawShapes = true;

            if (bDrawShapes) {

                if (strategy == null) {

                    strategy = new Annotation_Strategy(this);

                }

                g.setColor(Color.black);

                ReadableVectorial adapter = getSource();

                adapter.start();

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

                adapter.stop();

            }

            if (getVirtualLayers() != null) {

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

            }

        }

    }

    /**

     * @throws ReadDriverException

     * @throws InitializeDriverException

     * @throws ExpansionFileReadException

     * @see com.iver.cit.gvsig.fmap.layers.LayerOperations#getFullExtent()

     */

    public Rectangle2D getFullExtent() throws InitializeDriverException,

                        ReadDriverException, ExpansionFileReadException {

                Rectangle2D rAux;

                getSource().start();

                rAux = getSource().getFullExtent();

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

                }

                return rAux;

        }

    /**

         * @throws ReadDriverException

     * @see com.iver.cit.gvsig.fmap.layers.FLayer#print(java.awt.Graphics2D,

         *      com.iver.cit.gvsig.fmap.ViewPort,

         *      com.iver.utiles.swing.threads.Cancellable)

         */

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

        double scale, PrintRequestAttributeSet properties) throws ReadDriverException{

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

            Strategy strategy = StrategyManager.getStrategy(this);

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

        }

    }

    /*

     * (non-Javadoc)

     *

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.RandomVectorialData#queryByRect(java.awt.geom.Rectangle2D)

     */

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

        Strategy s = StrategyManager.getStrategy(this);

        return s.queryByRect(rect);

    }

    /**

     * DOCUMENT ME!

     *

     * @param p DOCUMENT ME!

     * @param tolerance DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     * @throws VisitorException

     * @throws ReadDriverException

     *

     * @throws DriverException DOCUMENT ME!

     */

    public FBitSet queryByPoint(Point2D p, double tolerance) throws ReadDriverException, VisitorException {

        Strategy s = StrategyManager.getStrategy(this);

        return s.queryByPoint(p, tolerance);

    }

    /**

     * DOCUMENT ME!

     *

     * @param g DOCUMENT ME!

     * @param relationship DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     * @throws VisitorException

     * @throws ReadDriverException

     *

     * @throws DriverException DOCUMENT ME!

     * @throws VisitException DOCUMENT ME!

     */

    public FBitSet queryByShape(IGeometry g, int relationship) throws ReadDriverException, VisitorException {

        Strategy s = StrategyManager.getStrategy(this);

        return s.queryByShape(g, relationship);

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     *

     * @throws XMLException

     *

     * @see com.iver.cit.gvsig.fmap.layers.FLayer#getProperties()

     */

    public XMLEntity getXMLEntity() throws XMLException {

        XMLEntity xml = super.getXMLEntity();

        return xml;

    }

    /**

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

     */

    public void setXMLEntity(XMLEntity xml) throws XMLException {

        IProjection proj = null;

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

            proj = CRSFactory.getCRS(xml.getStringProperty("proj"));

        }

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

            Driver d;

            try {

                d = LayerFactory.getDM().getDriver(xml.getStringProperty(

                            "driverName"));

            } catch (DriverLoadException e1) {

                throw new XMLException(e1);

            }

            FLyrVect lv = (FLyrVect) LayerFactory.createLayer(xml.getName(),

                    (VectorialFileDriver) d,

                    new File(xml.getStringProperty("file")), proj);

            try {

                this.setSource(lv.getSource());

                this.setRecordset(lv.getRecordset());

                this.setProjection(lv.getProjection());

                this.setLegend((IVectorLegend) lv.getLegend());

                Annotation_Mapping.addAnnotationMapping(this);

            } catch (ReadDriverException e) {

                    throw new XMLException(e);

                        } catch (LegendLayerException e) {

                                throw new XMLException(e);

                        }

        }

        super.setXMLEntity(xml);

    }

    public Value getSymbolKey(int i) throws ReadDriverException {

        SelectableDataSource ds = getRecordset();

        String t = new String();

        Value val = ds.getFieldValue(i, mapping.getColumnText());

        t = val.toString();

        if (mapping.getColumnColor() != -1) {

            Value valColor = ds.getFieldValue(i, mapping.getColumnColor());

            t = t.concat(valColor.toString());

        }

        if (mapping.getColumnTypeFont() != -1) {

            Value valTypeFont = ds.getFieldValue(i, mapping.getColumnTypeFont());

            t = t.concat(valTypeFont.toString());

        }

        if (mapping.getColumnStyleFont() != -1) {

            Value valStyleFont = ds.getFieldValue(i,

                    mapping.getColumnStyleFont());

            t = t.concat(valStyleFont.toString());

        }

        Value total = ValueFactory.createValue(t);

        return total;

    }

    /*

     * (non-Javadoc)

     *

     * @see com.iver.cit.gvsig.fmap.layers.layerOperations.RandomVectorialData#createIndex()

     */

    public void createSpatialIndex()  {

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

        // AZABALA: Como no tengo claro de donde se crean las capas de textos

        // el ?ndice espacial creado seguir? siendo el Quadtree en memoria

        // de JTS (QuadtreeJts es un adapter a nuestra api de indices)

        spatialIndex = new QuadtreeJts();

        ReadableVectorial va = getSource();

        ICoordTrans ct = getCoordTrans();

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

        try {

            va.start();

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

                Rectangle2D r = null;

                IGeometry geom = va.getShape(i);

                 if (geom != null) {

                    r = geom.getBounds2D();

                } else {

                    r = shapeBounds.getShapeBounds(i);

                }

                // TODO: MIRAR COMO SE TRAGAR?A ESTO LO DE LAS REPROYECCIONES

                if (ct != null) {

                    r = ct.convert(r);

                }

                if (r != null) {

                    spatialIndex.insert(r, i);

                }

            } // for

            va.stop();

        } catch (ExpansionFileReadException e) {

                        NotificationManager.addError(this.getName(),e);

                } catch (ReadDriverException e) {

                        NotificationManager.addError(this.getName(),e);

                }

    }

    /**

     * DOCUMENT ME!

     * @throws ReadDriverException

     *

     * @throws DriverException DOCUMENT ME!

     */

    public void setSelectedEditing() throws ReadDriverException {

        FBitSet bitSet = getRecordset().getSelection();

        if (bitSet.cardinality() == 0) {

            return;

        }

        indexEditing = bitSet.nextSetBit(0);

    }

    public void setInEdition(int i) {

        indexEditing = i;

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public int getInEdition() {

        return indexEditing;

    }

    public void setLegend() throws ReadDriverException, LegendLayerException {

        getSource().getRecordset().start();

        aLegend.setFieldName(getSource().getRecordset().getFieldName(mapping.getColumnText()));

        setLegend(aLegend);

        getSource().getRecordset().stop();

    }

    /**

     * DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     */

    public Strategy getStrategy() {

        return strategy;

    }

    /**

     * DOCUMENT ME!

     *

     * @param b DOCUMENT ME!

     * @throws StartEditionLayerException

     *

     * @throws EditionException DOCUMENT ME!

     */

    public void setEditing(boolean b) throws StartEditionLayerException {

       super.setEditing(b);

       try {

            if (b) {

                Annotation_EditableAdapter aea = new Annotation_EditableAdapter(this);

                                        aea.setOriginalVectorialAdapter(((VectorialEditableAdapter) super.getSource()).getOriginalAdapter());

                ((VectorialEditableAdapter) super.getSource()).cancelEdition(EditionEvent.GRAPHIC);

                aea.start();

                aea.setCoordTrans(getCoordTrans());

                // CHEMA

                aea.startEdition(EditionEvent.GRAPHIC);

                setSource(aea);

                getRecordset().setSelectionSupport(aea.getOriginalAdapter()

                                                      .getRecordset()

                                                      .getSelectionSupport());

            } else {

            }

               } catch (ReadDriverException e) {

                        throw new StartEditionLayerException(this.getName(),e);

                } catch (CancelEditingLayerException e) {

                        throw new StartEditionLayerException(this.getName(),e);

                } catch (StartWriterVisitorException e) {

                        throw new StartEditionLayerException(this.getName(),e);

                }

        deleteSpatialIndex();

    }

    /**

     * DOCUMENT ME!

     *

     * @param layer DOCUMENT ME!

     *

     * @return DOCUMENT ME!

     * @throws ReadDriverException

     *

     * @throws DriverException DOCUMENT ME!

     * @throws FieldNotFoundException DOCUMENT ME!

     */

    public static Annotation_Layer createLayerFromVect(FLyrVect layer) throws ReadDriverException {

        Annotation_Layer la = new Annotation_Layer();

        FLyrVect lv=(FLyrVect)LayerFactory.createLayer(layer.getName(),layer.getSource().getDriver(),layer.getProjection());

        la.setSource(lv.getSource());

        la.setRecordset(lv.getRecordset());

        la.setProjection(layer.getProjection());

        la.getRecordset().setSelection(layer.getRecordset().getSelection());

        return la;

    }

    /**

     * DOCUMENT ME!

     */

    public void removingThisLayer() {

//        super.removingThisLayer();

        spatialIndex = null;

        aLegend = null;

        strategy = null;

        System.gc();

    }

    public IGeometry getTextWrappingGeometryInPixels(double height, String description,

            double rotation, String type, int style, int numReg,ViewPort vp, IGeometry geom) {

            Shape shapeP=geom.getInternalShape();

            FPoint2D p = null;

            if (!(shapeP instanceof FPoint2D)) {

                    Rectangle2D rP=shapeP.getBounds2D();

                    p=new FPoint2D(rP.getX(),rP.getMaxY());

            }else {

                    p=(FPoint2D)shapeP;

            }

//            if (geom.getInternalShape() instanceof FPolygon2D){

//                    r=new Rectangle2D.Double(r.getX()-r.getWidth()*0.5,r.getY()-r.getHeight()*0.5,r.getWidth(),r.getHeight());

//            }

//            p=new Point2D.Double(r.getCenterX(),r.getCenterY());

            if (!((Annotation_Legend) getLegend()).isFontSizeInPixels()) {

                height = vp.fromMapDistance((int) (height));

            }

            Font font = new Font(type, style,

                    (int) (height));

            FontRenderContext frc = new FontRenderContext(ati,

                    false, true);

            GlyphVector gv = font.createGlyphVector(frc, description);

            Shape shape = gv.getOutline((float) p.getX(), (float) (p.getY()));// - height));

            Rectangle2D rGeom=shape.getBounds2D();

            IGeometry geomResult = ShapeFactory.createPolygon2D(new GeneralPathX(

                            rGeom));

            if (rotation != 0) {

                    AffineTransform Tx = AffineTransform.getRotateInstance(Math.toRadians(-rotation),p.getX(),p.getY());

                        geomResult.transform(Tx);

//                geomResult.transform(AffineTransform.getRotateInstance(Math.toRadians(-rotation),p.getX(),p.getY()));

//                geomResult.rotate(Math.toRadians(rotation), p.getX(),

//                        p.getY());

            }

            return geomResult;

        }

    public FLayer cloneLayer() throws Exception {

                Annotation_Layer clonedLayer = new Annotation_Layer();

                clonedLayer.setSource(getSource());

                clonedLayer.setVisible(isVisible());

                clonedLayer.setISpatialIndex(getISpatialIndex());

                clonedLayer.setName(getName());

                clonedLayer.setCoordTrans(getCoordTrans());

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

                clonedLayer.mapping=mapping;

                clonedLayer.aLegend=aLegend;

                return clonedLayer;

        }

}