Application: gvSIG desktop

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

import java.awt.Component;

import java.awt.Font;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.InputEvent;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import javax.swing.JLabel;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.app.ApplicationLocator;

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.dal.feature.FeatureType;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiPrimitive;

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

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

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

import org.gvsig.i18n.Messages;

import org.gvsig.tools.dispose.DisposableIterator;

//import com.vividsolutions.jts.geom.GeometryCollection;

/**

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

    private static Logger logger = LoggerFactory.getLogger(ExploitCADTool.class);

    protected ExploitCADToolContext _fsm;

    /**

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

        FeatureStore featureStore = null;

        FeatureType fety = null;

        try {

            featureStore = vle.getFeatureStore();

            fety = featureStore.getDefaultFeatureType();

        } catch (Exception ex) {

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

            return;

        }

        GeometryType gety = fety.getDefaultGeometryAttribute().getGeomType();

        /*

         * If we find a geometry which will violate

         * geometry type retriction after being exploded,

         * then we will ask user what to do (we'll ask once

         * for all cases)

         */

        boolean decisionHasBeenTaken = false;

        boolean differentTypesAllowed = false;

        if (gety.getType() == Geometry.TYPES.GEOMETRY) {

            /*

             * Multi allowed, so we don't need to ask

             */

            decisionHasBeenTaken = true;

            differentTypesAllowed = true;

        }

        // ==============================

        try {

            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 MultiPrimitive) {

                    exploitGeometryCollection(feature, newSelection);

                } else {

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

                        /*

                         * Splitting line gives lines, no problem

                         */

                        exploitLine(feature, newSelection);

                    } else {

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

                            if (decisionHasBeenTaken) {

                                /*

                                 * We have already decided what to do

                                 * in these cases

                                 */

                                exploitPolygon(

                                    feature,

                                    newSelection,

                                    differentTypesAllowed);

                            } else {

                                differentTypesAllowed = askUserAllowOther();

                                decisionHasBeenTaken = true;

                                /*

                                 * User has taken a decision. The same

                                 * decision applies for other geometries

                                 * in the current explode process

                                 */

                                exploitPolygon(

                                    feature,

                                    newSelection,

                                    differentTypesAllowed);

                            }

                        }

                    }

                }

            }

            // clearSelection();

            featureStore.setSelection(newSelection);

            featureStore.endEditingGroup();

        } catch (Exception e) {

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

        } finally {

            if (iterator != null) {

                iterator.dispose();

            }

        }

    }

    private void exploitGeometryCollection(Feature feature,

        FeatureSelection selectedRowAux) throws ReadException, DataException {

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

        MultiPrimitive gc = (MultiPrimitive) geom;

        int numGeoms = gc.getPrimitivesNumber();

        Feature f = null;

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

            Geometry primitiveGeom = gc.getPrimitiveAt(i);

            f = insertGeometry(primitiveGeom, feature);

            selectedRowAux.select(f);

        }

        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;

            Feature f = 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);

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

                        f = insertGeometry(geomLine, feature);

                        selectedRowAux.select(f);

                        newGp1 = new GeneralPathX();

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

                    }

                    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 deleted_feature,

        FeatureSelection selectedRowAux,

        boolean allows_other) {

        GeneralPathX newGp1 = null;

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

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

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

        // }

        FeatureStore featureStore;

        Feature added_feat = null;

        try {

            featureStore = getVLE().getFeatureStore();

            PathIterator theIterator =

                (deleted_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 new_part = null;

                        if (allows_other) {

                            new_part = createCurve(newGp1);

                            added_feat = cloneFeatureWithGeometry(new_part, deleted_feature);

                            /*

                             * added_feat not added

                             * Now explode resulting line

                             */

                            exploitLine(added_feat, selectedRowAux);

                        } else {

                            new_part = createSurface(newGp1);

                            added_feat = insertGeometry(new_part, deleted_feature);

                            selectedRowAux.select(added_feat);

                        }

                    }

                    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 new_part = null;

                if (allows_other) {

                    new_part = createCurve(newGp1);

                    added_feat = cloneFeatureWithGeometry(new_part, deleted_feature);

                    /*

                     * added_feat not added

                     * Now explode resulting line

                     */

                    exploitLine(added_feat, selectedRowAux);

                } else {

                    new_part = createSurface(newGp1);

                    added_feat = insertGeometry(new_part, deleted_feature);

                    selectedRowAux.select(added_feat);

                }

            }

        } catch (Throwable e) {

            logger.info("While doing exploit of polygon.", e);

            ApplicationLocator.getManager().message(

                "_Unable_to_exploit_polygon", JOptionPane.ERROR_MESSAGE);

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

    }

    @Override

    protected int[] getSupportedGeometryTypes() {

        return new int[] { CURVE, SURFACE };

    }

    /**

     * @return

     */

    private boolean askUserAllowOther() {

        int resp = 0;

        Object[] options = {

            Messages.getText("_Allow_lines"),

            Messages.getText("_Keep_as_polygons") };

        JPanel explanation_panel = getExplanationPanel();

        Component parent = ApplicationLocator.getManager().getRootComponent();

        resp = JOptionPane.showOptionDialog(

                    parent,

                    explanation_panel,

                    Messages.getText("exploit"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE, null, options,

                    options[1]);

        return (resp == JOptionPane.YES_OPTION);

    }

    private JPanel getExplanationPanel() {

        JPanel resp = new JPanel(new BorderLayout(10, 10));

        String msg = Messages.getText("_Polygons_will_exploded_in_polygon_only_layer_Decision_question");

        JLabel topLabel = new JLabel(msg);

        JPanel mainPanel = new JPanel(new GridBagLayout());

        GridBagConstraints cc = new GridBagConstraints();

        cc.gridx = 0;

        cc.gridy = 0;

        cc.anchor = GridBagConstraints.WEST;

        cc.insets = new Insets(3, 6, 3, 6);

        Font boldf = mainPanel.getFont().deriveFont(Font.BOLD);

        JLabel lbl = new JLabel(Messages.getText("_Allow_lines"));

        lbl.setFont(boldf);

        mainPanel.add(lbl, cc);

        cc.gridx = 1;

        mainPanel.add(new JLabel(Messages.getText("_Lines_will_exist_in_editing_mode_Must_remove_or_cancel")), cc);

        cc.gridx = 0;

        cc.gridy = 1;

        lbl = new JLabel(Messages.getText("_Keep_as_polygons"));

        lbl.setFont(boldf);

        mainPanel.add(lbl, cc);

        cc.gridx = 1;

        mainPanel.add(new JLabel(Messages.getText("_Multi_polygons_separated_Simple_polygons_kept")), cc);

        resp.add(mainPanel, BorderLayout.CENTER);

        resp.add(topLabel, BorderLayout.NORTH);

        return resp;

    }

    private Feature cloneFeatureWithGeometry(

        Geometry geometry, Feature feature) {

        VectorialLayerEdited vle = getVLE();

        try {

            FeatureStore featureStore =

                ((FLyrVect) vle.getLayer()).getFeatureStore();

            EditableFeature eFeature =

                featureStore.createNewFeature(

                    featureStore.getDefaultFeatureType(), feature);

            eFeature.setGeometry(featureStore.getDefaultFeatureType()

                .getDefaultGeometryAttributeName(), geometry);

            return eFeature;

        } catch (ReadException e) {

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

            return null;

        } catch (DataException e) {

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

            return null;

        }

    }

}