| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 * 

 * 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., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.editing.gui.cad.tools;

import java.awt.event.InputEvent;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import com.vividsolutions.jts.geom.GeometryCollection;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.editing.CADExtension;

import org.gvsig.editing.gui.cad.DefaultCADTool;

import org.gvsig.editing.gui.cad.exception.CommandException;

import org.gvsig.editing.gui.cad.tools.smc.ExploitCADToolContext;

import org.gvsig.editing.layers.VectorialLayerEdited;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.impl.BaseMultiPrimitive;

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

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

import org.gvsig.tools.dispose.DisposableIterator;

/**

 * Elimina la geometr?a compuesta y a?ade todas la geometr?as simples que la

 * componen, implementado para polil?neas y pol?gonos.

 * 

 * @author Vicente Caballero Navarro

 */

public class ExploitCADTool extends DefaultCADTool {

    protected ExploitCADToolContext _fsm;

    /**

     * Crea un nuevo ExploitCADTool.

     */

    public ExploitCADTool() {

    }

    /**

     * M?todo de inicio, para poner el c?digo de todo lo que se requiera de una

     * carga previa a la utilizaci?n de la herramienta.

     */

    public void init() {

        _fsm = new ExploitCADToolContext(this);

    }

    /*

     * (non-Javadoc)

     * 

     * @see

     * com.iver.cit.gvsig.gui.cad.CADTool#transition(com.iver.cit.gvsig.fmap

     * .layers.FBitSet, double, double)

     */

    public void transition(double x, double y, InputEvent event) {

        _fsm.addPoint(x, y, event);

    }

    /*

     * (non-Javadoc)

     * 

     * @see

     * com.iver.cit.gvsig.gui.cad.CADTool#transition(com.iver.cit.gvsig.fmap

     * .layers.FBitSet, double)

     */

    public void transition(double d) {

        _fsm.addValue(d);

    }

    /*

     * (non-Javadoc)

     * 

     * @see

     * com.iver.cit.gvsig.gui.cad.CADTool#transition(com.iver.cit.gvsig.fmap

     * .layers.FBitSet, java.lang.String)

     */

    public void transition(String s) throws CommandException {

        if (!super.changeCommand(s)) {

            _fsm.addOption(s);

        }

    }

    /**

     * DOCUMENT ME!

     */

    public void selection() {

        FeatureSet selection = null;

        try {

            selection = (FeatureSet) getVLE().getFeatureStore().getSelection();

            if (selection.getSize() == 0

                && !CADExtension

                    .getCADTool()

                    .getClass()

                    .getName()

                    .equals("com.iver.cit.gvsig.gui.cad.tools.SelectionCADTool")) {

                CADExtension.setCADTool("_selection", false);

                ((SelectionCADTool) CADExtension.getCADTool())

                    .setNextTool("_exploit");

            }

        } catch (ReadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (DataException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

    /**

     * Equivale al transition del prototipo pero sin pasarle como par?metro el

     * editableFeatureSource que ya estar? creado.

     * 

     * @param x

     *            par?metro x del punto que se pase en esta transici?n.

     * @param y

     *            par?metro y del punto que se pase en esta transici?n.

     */

    public void addPoint(double x, double y, InputEvent event) {

    }

    /**

     * M?todo para dibujar la lo necesario para el estado en el que nos

     * encontremos.

     * 

     * @param g

     *            Graphics sobre el que dibujar.

     * @param x

     *            par?metro x del punto que se pase para dibujar.

     * @param y

     *            par?metro x del punto que se pase para dibujar.

     */

    public void drawOperation(MapControlDrawer renderer, double x, double y) {

    }

    public void exploit() {

        VectorialLayerEdited vle = getVLE();

        DisposableIterator iterator = null;

        try {

            FeatureStore featureStore = vle.getFeatureStore();

            iterator =

                ((FeatureSelection) featureStore.getSelection()).iterator();

            FeatureSelection newSelection =

                featureStore.createFeatureSelection();

            // ArrayList selectedRowAux = new ArrayList();

            featureStore.beginEditingGroup(getName());

            while (iterator.hasNext()) {

                Feature feature = (Feature) iterator.next();

                Geometry geom = (feature.getDefaultGeometry()).cloneGeometry();

                featureStore.delete(feature);

                if (geom instanceof GeometryCollection) {

                    exploitGeometryCollection(feature, newSelection);

                } else {

                    if (geom.getType() == Geometry.TYPES.CURVE) {

                        exploitLine(feature, newSelection);

                    } else

                        if (geom.getType() == Geometry.TYPES.SURFACE) {

                            exploitPolygon(feature, newSelection);

                        }

                }

            }

            // clearSelection();

            featureStore.setSelection(newSelection);

            featureStore.endEditingGroup();

        } catch (DataException e) {

            NotificationManager.addError(e.getMessage(), e);

        } finally {

            if (iterator != null) {

                iterator.dispose();

            }

        }

    }

    private void exploitGeometryCollection(Feature feature,

        FeatureSelection selectedRowAux) {

        Geometry geom = (feature.getDefaultGeometry()).cloneGeometry();

        BaseMultiPrimitive gc = (BaseMultiPrimitive) geom;

        int numGeoms = gc.getPrimitivesNumber();

        FeatureStore featureStore;

        try {

            featureStore = getVLE().getFeatureStore();

            for (int i = 0; i < numGeoms; i++) {

                Geometry primitiveGeom = gc.getPrimitiveAt(i);

                EditableFeature eFeature =

                    featureStore.createNewFeature(feature.getType(), feature);

                eFeature.setGeometry(featureStore.getDefaultFeatureType()

                    .getDefaultGeometryAttributeName(), primitiveGeom);

                selectedRowAux.select(feature);

            }

        } catch (ReadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (DataException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        refresh();

    }

    private void exploitLine(Feature feature, FeatureSelection selectedRowAux) {

        GeneralPathX newGp1 = new GeneralPathX();

        // DefaultFeature df = (DefaultFeature) dre.getLinkedRow()

        // .cloneRow();

        // Point2D firstPoint=null;

        // Point2D lastPoint=null;

        // Object[] attributes=new Object[feature.size()];

        // for (int j = 0; j < feature.size(); j++) {

        // attributes[j]=feature.get(j);

        // }

        FeatureStore featureStore;

        // try {

        try {

            featureStore = getVLE().getFeatureStore();

            // EditableFeature

            // eFeature=featureStore.createNewFeature(feature.getType(),

            // feature);

            PathIterator theIterator =

                (feature.getDefaultGeometry()).getPathIterator(null,

                    geomManager.getFlatness());

            double[] theData = new double[6];

            int theType;

            int numParts = 0;

            Point2D initialPoint = null;

            while (!theIterator.isDone()) {

                theType = theIterator.currentSegment(theData);

                switch (theType) {

                case PathIterator.SEG_MOVETO:

                    numParts++;

                    newGp1 = new GeneralPathX();

                    // firstPoint=new Point2D.Double(theData[0], theData[1]);

                    initialPoint = new Point2D.Double(theData[0], theData[1]);

                    newGp1.moveTo(theData[0], theData[1]);

                    // lastPoint=new Point2D.Double(theData[0], theData[1]);

                    break;

                case PathIterator.SEG_LINETO:

                    newGp1.lineTo(theData[0], theData[1]);

                    Geometry geomLine = createCurve(newGp1);

                    // DefaultFeature dfLine = (DefaultFeature) df.cloneRow();

                    // dfLine.setGeometry(geomLine);

                    // EditableFeature

                    // eFeature=featureStore.createNewFeature(feature.getType(),

                    // feature);

                    // eFeature.setGeometry(featureStore.getDefaultFeatureType().getDefaultGeometryAttributeName(),geomLine);

                    Feature f = insertGeometry(geomLine, feature);

                    // featureStore.insert(eFeature);

                    selectedRowAux.select(f);

                    newGp1 = new GeneralPathX();

                    newGp1.moveTo(theData[0], theData[1]);

                    // lastPoint=new Point2D.Double(theData[0], theData[1]);

                    break;

                case PathIterator.SEG_CLOSE:

                    if (initialPoint != null) {

                        newGp1.lineTo(initialPoint.getX(), initialPoint.getY());

                        geomLine = createCurve(newGp1);

                        // dfLine = (DefaultFeature) df.cloneRow();

                        // dfLine.setGeometry(geomLine);

                        EditableFeature eFeatureClose =

                            featureStore.createNewFeature(feature.getType(),

                                feature);

                        eFeatureClose.setGeometry(featureStore

                            .getDefaultFeatureType()

                            .getDefaultGeometryAttributeName(), geomLine);

                        selectedRowAux.select(eFeatureClose);

                        newGp1 = new GeneralPathX();

                        newGp1.moveTo(initialPoint.getX(), initialPoint.getY());

                    }

                    break;

                /*

                 * case PathIterator.SEG_QUADTO:

                 * Point2D current=newGp1.getCurrentPoint();

                 * newGp1.quadTo(theData[0], theData[1], theData[2],

                 * theData[3]);

                 * IGeometry geomQuad = ShapeFactory

                 * .createArc(current,new Point2D.Double(theData[0],

                 * theData[1]),new Point2D.Double(theData[2], theData[3]));

                 * DefaultFeature dfQuad = (DefaultFeature) df.cloneRow();

                 * dfQuad.setGeometry(geomQuad);

                 * int indexQuad = addGeometry(geomQuad, dfQuad

                 * .getAttributes());

                 * selectedRowAux.add(new DefaultRowEdited(dfQuad,

                 * IRowEdited.STATUS_ADDED, indexQuad));

                 * newGp1 = new GeneralPathX();

                 * newGp1.moveTo(theData[0], theData[1]);

                 * // lastPoint=new Point2D.Double(theData[0], theData[1]);

                 * break;

                 * case PathIterator.SEG_CUBICTO:

                 * newGp1.curveTo(theData[0], theData[1], theData[2],

                 * theData[3], theData[4], theData[5]);

                 * IGeometry geomCurve = ShapeFactory

                 * .createArc(new Point2D.Double(theData[0], theData[1]),new

                 * Point2D.Double(theData[2], theData[3]),new

                 * Point2D.Double(theData[4], theData[5]));

                 * DefaultFeature dfCurve = (DefaultFeature) df.cloneRow();

                 * dfCurve.setGeometry(geomCurve);

                 * int indexCurve = addGeometry(geomCurve, dfCurve

                 * .getAttributes());

                 * selectedRowAux.add(new DefaultRowEdited(dfCurve,

                 * IRowEdited.STATUS_ADDED, indexCurve));

                 * newGp1 = new GeneralPathX();

                 * newGp1.moveTo(theData[0], theData[1]);

                 * // lastPoint=new Point2D.Double(theData[0], theData[1]);

                 * break;

                 * case PathIterator.SEG_CLOSE:

                 * // if (firstPoint!=null) {

                 * // newGp1=new GeneralPathX();

                 * // newGp1.moveTo(firstPoint.getX(),firstPoint.getY());

                 * // newGp1.lineTo(lastPoint.getX(),lastPoint.getY());

                 * // IGeometry geomClose = ShapeFactory

                 * // .createPolyline2D(newGp1);

                 * // DefaultFeature dfClose = (DefaultFeature) df.cloneRow();

                 * // dfClose.setGeometry(geomClose);

                 * // int indexClose = addGeometry(geomClose, dfClose

                 * // .getAttributes());

                 * // selectedRowAux.add(new DefaultRowEdited(dfClose,

                 * // IRowEdited.STATUS_ADDED, indexClose));

                 * // newGp1 = new GeneralPathX();

                 * // newGp1.moveTo(theData[0], theData[1]);

                 * // }

                 * // if (isFirstPart)

                 * // newGp1.closePath();

                 * // else

                 * // newGp2.closePath();

                 * break;

                 */

                } // end switch

                theIterator.next();

            } // end while loop

        } catch (ReadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (DataException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        refresh();

    }

    private void exploitPolygon(Feature feature, FeatureSelection selectedRowAux) {

        GeneralPathX newGp1 = null;

        // Object[] attributes=new Object[feature.size()];

        // for (int j = 0; j < feature.size(); j++) {

        // attributes[j]=feature.get(j);

        // }

        FeatureStore featureStore;

        try {

            featureStore = getVLE().getFeatureStore();

            PathIterator theIterator =

                (feature.getDefaultGeometry()).getPathIterator(null,

                    geomManager.getFlatness());

            double[] theData = new double[6];

            int theType;

            int numParts = 0;

            Point2D initialPoint = null;

            while (!theIterator.isDone()) {

                theType = theIterator.currentSegment(theData);

                switch (theType) {

                case PathIterator.SEG_MOVETO:

                    numParts++;

                    if (newGp1 != null) {

                        Geometry geomLine = createCurve(newGp1);

                        EditableFeature eFeature =

                            featureStore.createNewFeature(feature.getType(),

                                feature);

                        eFeature.setGeometry(featureStore

                            .getDefaultFeatureType()

                            .getDefaultGeometryAttributeName(), geomLine);

                        selectedRowAux.select(eFeature);

                    }

                    newGp1 = new GeneralPathX();

                    initialPoint = new Point2D.Double(theData[0], theData[1]);

                    newGp1.moveTo(theData[0], theData[1]);

                    break;

                case PathIterator.SEG_LINETO:

                    newGp1.lineTo(theData[0], theData[1]);

                    // newGp1 = new GeneralPathX();

                    // newGp1.moveTo(theData[0], theData[1]);

                    break;

                case PathIterator.SEG_QUADTO:

                    newGp1.quadTo(theData[0], theData[1], theData[2],

                        theData[3]);

                    // newGp1 = new GeneralPathX();

                    // newGp1.moveTo(theData[0], theData[1]);

                    break;

                case PathIterator.SEG_CUBICTO:

                    newGp1.curveTo(theData[0], theData[1], theData[2],

                        theData[3], theData[4], theData[5]);

                    // newGp1 = new GeneralPathX();

                    // newGp1.moveTo(theData[0], theData[1]);

                    break;

                case PathIterator.SEG_CLOSE:

                    if (initialPoint != null) {

                        newGp1.lineTo(initialPoint.getX(), initialPoint.getY());

                    }

                    // System.out.println("aqu?");

                    // if (isFirstPart)

                    // newGp1.closePath();

                    // else

                    // newGp2.closePath();

                    break;

                } // end switch

                theIterator.next();

            } // end while loop

            if (newGp1 != null) {

                Geometry geomLine = createCurve(newGp1);

                EditableFeature eFeature =

                    featureStore.createNewFeature(feature.getType(), feature);

                eFeature.setGeometry(featureStore.getDefaultFeatureType()

                    .getDefaultGeometryAttributeName(), geomLine);

                selectedRowAux.select(eFeature);

            }

        } catch (ReadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (DataException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        refresh();

    }

    /**

     * Add a diferent option.

     * 

     * @param s

     *            Diferent option.

     */

    public void addOption(String s) {

    }

    /*

     * (non-Javadoc)

     * 

     * @see com.iver.cit.gvsig.gui.cad.CADTool#addvalue(double)

     */

    public void addValue(double d) {

    }

    public String getName() {

        return PluginServices.getText(this, "exploit_");

    }

    public String toString() {

        return "_exploit";

    }

    public boolean isApplicable(int shapeType) {

        switch (shapeType) {

        case Geometry.TYPES.POINT:

        case Geometry.TYPES.CIRCLE:

        case Geometry.TYPES.ARC:

        case Geometry.TYPES.ELLIPSE:

        case Geometry.TYPES.SURFACE:

        case Geometry.TYPES.MULTIPOINT:

            return false;

        }

        return true;

    }

}