Application: gvSIG desktop » gvSIG tools: Derived geometries

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <parent>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.derivedgeometries.swing</artifactId>

    <version>1.0.113</version>

  </parent>

  <artifactId>org.gvsig.derivedgeometries.swing.impl</artifactId>

  <name>org.gvsig.derivedgeometries.swing.impl</name>

  <dependencies>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.tools.swing.api</artifactId>

  		<scope>compile</scope>

  	</dependency>

  	<dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.tools.swing.impl</artifactId>

        <scope>runtime</scope>

    </dependency>

  	<dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.derivedgeometries.swing.api</artifactId>

    </dependency>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.fmap.dal.api</artifactId>

  	</dependency>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.fmap.dal.swing.api</artifactId>

  	</dependency>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.fmap.dal.file.shp</artifactId>

  	</dependency>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.fmap.dal.impl</artifactId>

  		<scope>runtime</scope>

  	</dependency>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.fmap.dal.file.dbf</artifactId>

  	</dependency>

  	<dependency>

  		<groupId>org.gvsig</groupId>

  		<artifactId>org.gvsig.fmap.dal.file.lib</artifactId>

  	</dependency>

  </dependencies>

</project>

org.gvsig.derivedgeometries.swing.impl.DefaultDerivedGeometriesLibrary

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.derivedgeometries.swing.impl;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesLibrary;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesLocator;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.geom.GeometryLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * Library for default swing implementation initialization and configuration.

 *

 * @author gvSIG team

 * @version $Id$

 */

public class DefaultDerivedGeometriesLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(DerivedGeometriesLibrary.class);

        require(DALLibrary.class);

        require(GeometryLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        DerivedGeometriesLocator

            .registerManager(DefaultDerivedGeometriesManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        // Do nothing

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.derivedgeometries.swing.impl.panels;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.util.Vector;

import javax.swing.JComponent;

import javax.swing.JFileChooser;

import javax.swing.JOptionPane;

import org.apache.commons.io.FilenameUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesLocator;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesParameters;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesProcess.TYPE;

import org.gvsig.derivedgeometries.swing.api.exceptions.ValidateSourceLayerException;

import org.gvsig.derivedgeometries.swing.api.panels.LayerAndProcessSelectionPanel;

import org.gvsig.derivedgeometries.swing.impl.views.LayerAndProcessSelectionPanelView;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

import org.gvsig.fmap.geom.Geometry;

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

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

import org.gvsig.fmap.mapcontext.MapContext;

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

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

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

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

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

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

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.utils.GenericFileFilter;

public class DefaultLayerAndProcessSelectionPanel extends

    LayerAndProcessSelectionPanelView implements LayerAndProcessSelectionPanel {

    private static final long serialVersionUID = 1032294236575442328L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultLayerAndProcessSelectionPanel.class);

    private final String[] SHAPE_EXTENSIONS = { "shp", "SHP", "Shp", "sHp",

        "SHp", "shP", "ShP", "sHP" };

    private MapControl mapControl;

    private DerivedGeometriesParameters parameters;

    public DefaultLayerAndProcessSelectionPanel(MapControl mapControl) {

        super();

        this.mapControl = mapControl;

        initSourceLayerCombo();

        initProcessCombo();

        initSelectPathButton();

        addVectorialLayers();

        initMapControlListeners();

    }

    @SuppressWarnings("unchecked")

    private void addVectorialLayers() {

        getLayersComboBox().removeAllItems();

        FLayers flayers = mapControl.getMapContext().getLayers();

        for (FLyrVect layer : getVectorialLayers(flayers)) {

            getLayersComboBox().addItem(layer);

        }

    }

    public JComponent asJComponent() {

        return this;

    }

    public void closePanel() {

        setVisible(false);

    }

    private void deleteShapeFiles(FLyrVect sourceLayer, String outputLayerPath) {

        DataManager dataManager = DALLocator.getDataManager();

        try {

            DataServerExplorerParameters eparams =

                dataManager

                    .createServerExplorerParameters("FilesystemExplorer");

            eparams.setDynValue("initialpath", "/data");

            DataServerExplorer serverExplorer =

                dataManager.openServerExplorer(eparams.getExplorerName(),

                    eparams);

            DataStoreParameters dataStoreParams =

                dataManager.createStoreParameters("Shape");

            dataStoreParams.setDynValue("shpfile", outputLayerPath);

            dataStoreParams.setDynValue("CRS", sourceLayer.getProjection());

            dataStoreParams.setDynValue("useNullGeometry", false);

            dataStoreParams.validate();

            serverExplorer.remove(dataStoreParams);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public void doAccept() {

        FLyrVect sourceLayer = (FLyrVect) getLayersComboBox().getSelectedItem();

        String outputLayerName = getOutputLayerName().getText();

        String outputLayerPath = getOutputLayerPath().getText();

        String type = (String) getOutputShapeTypeCombo().getSelectedItem();

        File outputLayer = new File(outputLayerPath);

        // If file exist, it will delete shape files to overwrite shape.

        if (exist(outputLayer)) {

            deleteShapeFiles(sourceLayer, outputLayerPath);

        }

        int outputLayerType = 0;

        if (type.equalsIgnoreCase("Multicurve")) {

            outputLayerType = TYPES.MULTICURVE;

        } else if (type.equalsIgnoreCase("Surface")) {

            outputLayerType = TYPES.SURFACE;

        }

        TYPE processType = (TYPE) getProcessCombo().getSelectedItem();

        parameters =

            DerivedGeometriesLocator.getManager()

                .createDerivedGeometriesParameters(mapControl, sourceLayer,

                    outputLayerName, outputLayerPath, outputLayerType,

                    processType);

    }

    public void doCancel() {

        closePanel();

    }

    public DerivedGeometriesParameters getParameters() {

        return parameters;

    }

    private boolean exist(File file) {

        String pathWithoutExtension =

            FilenameUtils.removeExtension(file.getAbsolutePath());

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

            String path = pathWithoutExtension + "." + SHAPE_EXTENSIONS[i];

            File tmpFile = new File(path);

            if (tmpFile.exists()) {

                return true;

            }

        }

        return false;

    }

    private Vector<FLyrVect> getVectorialLayers(FLayers flayers) {

        Vector<FLyrVect> vectorialLayers = new Vector<FLyrVect>();

        for (int i = 0; i < flayers.getLayersCount(); i++) {

            if (flayers.getLayer(i) instanceof FLyrVect) {

                vectorialLayers.add((FLyrVect) flayers.getLayer(i));

            } else if (flayers.getLayer(i) instanceof FLayers) {

                FLayers group = ((FLayers) flayers.getLayer(i));

                vectorialLayers.addAll(getVectorialLayers(group));

            }

        }

        return vectorialLayers;

    }

    private void initMapControlListeners() {

        MapContext context = mapControl.getMapContext();

        FLayers layers = context.getLayers();

        layers.addLayerCollectionListener(new LayerCollectionListener() {

            public void layerAdded(LayerCollectionEvent e) {

                FLayer layer = e.getAffectedLayer();

                if (layer instanceof FLyrVect) {

                    getLayersComboBox().addItem(layer);

                }

            }

            public void layerAdding(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void layerMoved(LayerPositionEvent e) {

            }

            public void layerMoving(LayerPositionEvent e)

                throws CancelationException {

            }

            public void layerRemoved(LayerCollectionEvent e) {

                FLayer layer = e.getAffectedLayer();

                if (layer instanceof FLyrVect) {

                    getLayersComboBox().removeItem(layer);

                }

            }

            public void layerRemoving(LayerCollectionEvent e)

                throws CancelationException {

            }

            public void visibilityChanged(LayerCollectionEvent e)

                throws CancelationException {

            }

        });

    }

    private void initProcessCombo() {

        getProcessCombo().addActionListener(new ActionListener() {

            @SuppressWarnings("unchecked")

            public void actionPerformed(ActionEvent e) {

                // Update the other comboBox

                TYPE processType = (TYPE) getProcessCombo().getSelectedItem();

                if (processType != null) {

                    switch (processType) {

                    case POINTS_TO_LINE:

                        getOutputShapeTypeCombo().removeAllItems();

                        getOutputShapeTypeCombo().addItem("Multicurve");

                        break;

                    case POINTS_TO_POLYGON:

                        getOutputShapeTypeCombo().removeAllItems();

                        getOutputShapeTypeCombo().addItem("Surface");

                        break;

                    default:

                        break;

                    }

                }

            }

        });

    }

    private void initSelectPathButton() {

        getJButtonSelectPath().addActionListener(

            new java.awt.event.ActionListener() {

                public void actionPerformed(java.awt.event.ActionEvent e) {

                    ThreadSafeDialogsManager dlgManager =

                        ToolsSwingLocator.getThreadSafeDialogsManager();

                    I18nManager i18nManager = ToolsLocator.getI18nManager();

                    File[] files =

                        dlgManager.showChooserDialog(

                            i18nManager

                                .getTranslation("shape_file"),

                            JFileChooser.OPEN_DIALOG,

                            JFileChooser.FILES_ONLY,

                            false,

                            new File(System.getProperty("user.home")),

                            new GenericFileFilter(SHAPE_EXTENSIONS, i18nManager

                                .getTranslation("shape_file") + " (*.shp)"),

                            true);

                    if (files == null) {

                        return;

                    }

                    if (files.length == 1) {

                        File file = files[0];

                        String extension =

                            FilenameUtils.getExtension(file.getAbsolutePath());

                        if (extension == "") {

                            StringBuilder stb = new StringBuilder();

                            stb.append(file.getAbsolutePath());

                            stb.append(".");

                            stb.append(SHAPE_EXTENSIONS[0]);

                            file = new File(stb.toString());

                        }

                        if (exist(file)) {

                            String title =

                                i18nManager

                                    .getTranslation("_file_already_exist");

                            String message =

                                i18nManager

                                    .getTranslation("_file_already_exist_override_it");

                            int answer =

                                dlgManager.confirmDialog(message, title,

                                    JOptionPane.YES_NO_OPTION,

                                    JOptionPane.INFORMATION_MESSAGE);

                            if (answer == JOptionPane.YES_OPTION) {

                                getOutputLayerPath().setText(

                                    file.getAbsolutePath());

                            } else {

                                return;

                            }

                        } else {

                            getOutputLayerPath()

                                .setText(file.getAbsolutePath());

                        }

                    }

                }

            });

    }

    private void initSourceLayerCombo() {

        getLayersComboBox().addActionListener(new ActionListener() {

            @SuppressWarnings("unchecked")

            public void actionPerformed(ActionEvent e) {

                FLyrVect selectedLayer =

                    (FLyrVect) getLayersComboBox().getSelectedItem();

                GeometryType featureGeomType = null;

                getOutputShapeTypeCombo().removeAllItems();

                getProcessCombo().removeAllItems();

                if (selectedLayer != null) {

                    FeatureStore featureStore = selectedLayer.getFeatureStore();

                    try {

                        featureGeomType =

                            featureStore.getDefaultFeatureType()

                                .getDefaultGeometryAttribute().getGeomType();

                    } catch (DataException ex) {

                        String message =

                            String.format("Error getting feature type of %1",

                                featureStore);

                        LOG.info(message, ex);

                        return;

                    }

                    if (featureGeomType.isTypeOf(Geometry.TYPES.POINT)

                        || featureGeomType.isTypeOf(Geometry.TYPES.MULTIPOINT)) {

                        setSelectableComponentsEnabled(true);

                        getOutputShapeTypeCombo().addItem("Multicurve");

                        getProcessCombo().addItem(TYPE.POINTS_TO_LINE);

                        getProcessCombo().addItem(TYPE.POINTS_TO_POLYGON);

                    } else if (featureGeomType

                        .isTypeOf(Geometry.TYPES.MULTICURVE)) {

                        setSelectableComponentsEnabled(true);

                        getOutputShapeTypeCombo().addItem("Surface");

                        getProcessCombo()

                            .addItem(TYPE.LINES_TO_CLOSED_POLYLINE);

                    } else {

                        setSelectableComponentsEnabled(false);

                        getOutputLayerName().setText("");

                        getOutputLayerPath().setText("");

                    }

                }

            }

        });

    }

    public void setMapControl(MapControl mapControl) {

        this.mapControl = mapControl;

    }

    private void setSelectableComponentsEnabled(boolean b) {

        getOutputLayerPath().setEnabled(b);

        getOutputLayerName().setEnabled(b);

        getOutputShapeTypeCombo().setEnabled(b);

        getJButtonSelectPath().setEnabled(b);

        getProcessCombo().setEnabled(b);

    }

    public boolean validateFields() {

        FLyrVect sourceLayer = (FLyrVect) getLayersComboBox().getSelectedItem();

        String outputLayerName = getOutputLayerName().getText();

        String outputLayerPath = getOutputLayerPath().getText();

        if (sourceLayer != null && outputLayerName.length() > 0

            && outputLayerPath.length() > 0) {

            return true;

        } else {

            return false;

        }

    }

    public boolean validateSourceLayer() throws ValidateSourceLayerException {

        FLyrVect sourceLayer = (FLyrVect) getLayersComboBox().getSelectedItem();

        FeatureStore featureStore = sourceLayer.getFeatureStore();

        GeometryType featureGeomType;

        try {

            featureGeomType =

                featureStore.getDefaultFeatureType()

                    .getDefaultGeometryAttribute().getGeomType();

        } catch (DataException e) {

            String message =

                String.format(

                    "Error validating %1. Can't get feature geometry type",

                    sourceLayer);

            throw new ValidateSourceLayerException(message, e);

        }

        if (featureGeomType.isTypeOf(Geometry.TYPES.POINT)

            || featureGeomType.isTypeOf(Geometry.TYPES.MULTIPOINT)

            || featureGeomType.isTypeOf(Geometry.TYPES.MULTICURVE)) {

            return true;

        }

        return false;

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.derivedgeometries.swing.impl.panels;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesParameters;

import org.gvsig.derivedgeometries.swing.api.exceptions.DerivedGeometriesException;

import org.gvsig.derivedgeometries.swing.api.exceptions.ValidateSourceLayerException;

import org.gvsig.derivedgeometries.swing.api.panels.DerivedGeometriesPanel;

import org.gvsig.derivedgeometries.swing.impl.views.DerivedGeometriesPanelView;

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

import org.gvsig.fmap.mapcontrol.MapControl;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

public class DefaultDerivedGeometriesPanel extends DerivedGeometriesPanelView

    implements DerivedGeometriesPanel {

    private static final long serialVersionUID = -2874430817496441084L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultDerivedGeometriesPanel.class);

    public DefaultDerivedGeometriesPanel(MapControl theMapControl) {

        super(theMapControl);

        initNextButton();

        initCancelButton();

    }

    public JComponent asJComponent() {

        return this;

    }

    private void closeWindow() {

        setVisible(false);

    }

    private void initCancelButton() {

        getCancelButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                DerivedGeometriesParameters parameters = null;

                if (getLayerAndProcessSelectionPanel().asJComponent()

                    .isVisible()) {

                    parameters =

                        getLayerAndProcessSelectionPanel().getParameters();

                } else if (getFeaturesControlPanel().asJComponent().isVisible()) {

                    parameters = getFeaturesControlPanel().getParameters();

                }

                if(parameters != null){

                    FeatureStore featureStore = parameters.getFeatureStore();

                    if (featureStore != null) {

                        featureStore.dispose();

                    }

                }

                closeWindow();

            }

        });

    }

    private void initNextButton() {

        getNextButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                ThreadSafeDialogsManager dlgManager =

                    ToolsSwingLocator.getThreadSafeDialogsManager();

                if (getLayerAndProcessSelectionPanel().asJComponent()

                    .isVisible()) {

                    // If selected source layer is not valid shows a dialog and

                    // finish method

                    try {

                        if (!validateSelectedSourceLayer()) {

                            String title = "_no_valid_source_layer";

                            String message = "_cant_process_this_type_of_layer";

                            dlgManager.messageDialog(message, title,

                                JOptionPane.ERROR_MESSAGE);

                            return;

                        }

                    } catch (DerivedGeometriesException ex) {

                        LOG.warn("Error validating source layer", ex);

                        return;

                    }

                    if (validateLayerAndOutputLayerFields()) {

                        getLayerAndProcessSelectionPanel().doAccept();

                        DerivedGeometriesParameters parameters =

                            getLayerAndProcessSelectionPanel().getParameters();

                        getLayerAndProcessSelectionPanel().asJComponent()

                            .setVisible(false);

                        getFeaturesControlPanel().setParameters(parameters);

                        getFeaturesControlPanel().asJComponent().setVisible(

                            true);

                        I18nManager i18nManager = ToolsLocator.getI18nManager();

                        getCancelButton().setText(

                            i18nManager.getTranslation("finish"));

                        getNextButton().setText(

                            i18nManager.getTranslation("generate"));

                    } else {

                        // If data fields is no valid shows a dialog and finish

                        // method

                        String title = "_no_valid_data";

                        String message =

                            "_no_valid_data_make_sure_data_are_valid";

                        dlgManager.messageDialog(message, title,

                            JOptionPane.ERROR_MESSAGE);

                        return;

                    }

                } else if (getFeaturesControlPanel().asJComponent().isVisible()) {

                    if (validateFeaturesControlPanelFields()) {

                        getFeaturesControlPanel().doAction();

                    } else {

                        // If data fields is no valid shows a dialog and finish

                        // method

                        String title = "_no_valid_data";

                        String message =

                            "_no_valid_data_make_sure_data_are_valid";

                        dlgManager.messageDialog(message, title,

                            JOptionPane.ERROR_MESSAGE);

                        return;

                    }

                }

            }

        });

    }

    private boolean validateLayerAndOutputLayerFields() {

        return getLayerAndProcessSelectionPanel().validateFields();

    }

    private boolean validateFeaturesControlPanelFields() {

        return getFeaturesControlPanel().validateFields();

    }

    private boolean validateSelectedSourceLayer()

        throws ValidateSourceLayerException {

        return getLayerAndProcessSelectionPanel().validateSourceLayer();

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.derivedgeometries.swing.impl.panels;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.List;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesLocator;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesManager;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesParameters;

import org.gvsig.derivedgeometries.swing.api.exceptions.DerivedGeometriesException;

import org.gvsig.derivedgeometries.swing.api.exceptions.FetaureTableModelException;

import org.gvsig.derivedgeometries.swing.api.panels.FeaturesControlPanel;

import org.gvsig.derivedgeometries.swing.api.tablemodels.DerivedGeometriesSelectionModel;

import org.gvsig.derivedgeometries.swing.impl.views.FeaturesControlPanelView;

import org.gvsig.derivedgeometries.swing.impl.views.SelectedFeaturesTableModel;

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

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

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

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

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

public class DefaultFeaturesControlPanel extends FeaturesControlPanelView

    implements FeaturesControlPanel {

    private static final long serialVersionUID = -2215258264697623544L;

    private static final Logger LOG = LoggerFactory

        .getLogger(DefaultFeaturesControlPanel.class);

    private List<FeatureReference> features;

    private DerivedGeometriesParameters parameters;

    public DefaultFeaturesControlPanel() {

        super();

        features = new ArrayList<FeatureReference>();

        initAddAllButton();

        initRemoveAllButton();

        initAddButton();

        initRemoveButton();

        initMoveUpButton();

        initMoveDownButton();

    }

    public JComponent asJComponent() {

        return this;

    }

    public void doAction() {

        getParameters().setSelectedFeatures(features);

        DerivedGeometriesManager manager =

            DerivedGeometriesLocator.getManager();

        manager.startDerivedGeometriesProcess(parameters);

        getSelectedFeaturesTableModel().clear();

        features.clear();

    }

    public DerivedGeometriesParameters getParameters() {

        return this.parameters;

    }

    private int[] getSelectedIndexs() {

        if (features == null || features.size() == 0) {

            return new int[-1];

        }

        return getSelectedFeaturesTable().getSelectedRows();

    }

    private boolean hasMoreThanOneGeometry(Feature feature) {

        Geometry geom = feature.getDefaultGeometry();

        if (geom instanceof Aggregate) {

            if (((Aggregate) geom).getPrimitivesNumber() > 1) {

                return true;

            }

        }

        return false;

    }

    private void initAddAllButton() {

        getAddAllButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                FeatureStore featureStore =

                    getParameters().getSourceLayer().getFeatureStore();

                final List<FeatureReference> tmpFeatures =

                    new ArrayList<FeatureReference>();

                boolean showWarningDialog = false;

                DisposableIterator it = null;

                FeatureSet featureSet = null;

                try {

                    featureSet = featureStore.getFeatureSet();

                    it = featureSet.fastIterator();

                } catch (DataException ex) {

                    String message =

                        String.format(

                            "Error getting feature set or fast iterator of %1",

                            featureStore);

                    LOG.info(message, ex);

                    return;

                }

                while (it.hasNext()) {

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

                    if (hasMoreThanOneGeometry(feature)

                        || feature.getDefaultGeometry() == null) {

                        showWarningDialog = true;

                    } else {

                        tmpFeatures.add(feature.getCopy().getReference());

                    }

                }

                it.dispose();

                featureSet.dispose();

                if (showWarningDialog) {

                    showWarningDialog();

                }

                features = tmpFeatures;

                try {

                    getSelectedFeaturesTableModel().loadData(features);

                } catch (DerivedGeometriesException ex) {

                    LOG.info("Error loading features", ex);

                }

            }

        });

    }

    private void initAddButton() {

        getAddButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                FeatureStore featureStore =

                    getParameters().getSourceLayer().getFeatureStore();

                boolean showWarningDialog = false;

                DerivedGeometriesSelectionModel selectionModel = null;

                try {

                    selectionModel =

                        (DerivedGeometriesSelectionModel) getAllFeaturesTable(

                            featureStore).getSelectionModel();

                } catch (FetaureTableModelException e1) {

                    // TODO Auto-generated catch block

                    e1.printStackTrace();

                }

                if (showWarningDialog) {

                    showWarningDialog();

                }

                features.addAll(selectionModel.getSelectedFeatures());

                selectionModel.getSelectedFeatures().clear();

                try {

                    getSelectedFeaturesTableModel().loadData(features);

                } catch (DerivedGeometriesException ex) {

                    LOG.info("Error loading features", ex);

                }

            }

        });

    }

    private void initMoveDownButton() {

        getMoveDownButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                int[] currIndexs = getSelectedIndexs();

                // If selected is the last row, do nothing

                if (currIndexs.length <= 0

                    || currIndexs[currIndexs.length - 1] >= features.size() - 1) {

                    return; // nothing to do

                }

                List<FeatureReference> selectedFeatures =

                    new ArrayList<FeatureReference>();

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

                    FeatureReference selected = null;

                    selected = features.get(currIndexs[i]);

                    selectedFeatures.add(selected);

                }

                if (!selectedFeatures.isEmpty()) {

                    features.removeAll(selectedFeatures);

                    for (int i = 0; i < selectedFeatures.size(); i++) {

                        FeatureReference selected = selectedFeatures.get(i);

                        features.add(currIndexs[i] + 1, selected);

                    }

                    try {

                        // Reload table

                        getSelectedFeaturesTableModel().loadData(features);

                    } catch (DerivedGeometriesException ex) {

                        LOG.info("Error loading features", ex);

                        return;

                    }

                    // Keeps rows selected. We have to add one due to

                    // displacement.

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

                        getSelectedFeaturesTable().addRowSelectionInterval(

                            currIndexs[i] + 1, currIndexs[i] + 1);

                    }

                }

            }

        });

    }

    private void initMoveUpButton() {

        getMoveUpButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                int[] currIndexs = getSelectedIndexs();

                // If selected is the first row, do nothing

                if (currIndexs.length <= 0 || currIndexs[0] == 0) {

                    return;

                }

                List<FeatureReference> selectedFeatures =

                    new ArrayList<FeatureReference>();

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

                    FeatureReference selected = null;

                    try {

                        selected =

                            features.get(currIndexs[i]).getFeature()

                                .getReference();

                    } catch (DataException ex) {

                        LOG.info("Error getting feature", ex);

                        return;

                    }

                    selectedFeatures.add(selected);

                }

                if (!selectedFeatures.isEmpty()) {

                    features.removeAll(selectedFeatures);

                    for (int i = 0; i < selectedFeatures.size(); i++) {

                        FeatureReference selected = selectedFeatures.get(i);

                        features.add(currIndexs[i] - 1, selected);

                    }

                    // Reload table

                    try {

                        getSelectedFeaturesTableModel().loadData(features);

                    } catch (DerivedGeometriesException ex) {

                        LOG.info("Error loading features", ex);

                        return;

                    }

                    // Keeps rows selected. We have to subtract one due to

                    // displacement.

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

                        getSelectedFeaturesTable().addRowSelectionInterval(

                            currIndexs[i] - 1, currIndexs[i] - 1);

                    }

                }

            }

        });

    }

    private void initRemoveAllButton() {

        getRemoveAllButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                if (!features.isEmpty()) {

                    getSelectedFeaturesTableModel().clear();

                    features.clear();

                }

            }

        });

    }

    private void initRemoveButton() {

        getRemoveButton().addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                int[] selectedRows =

                    getSelectedFeaturesTable().getSelectedRows();

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

                    features.remove(selectedRows[i]);

                }

                try {

                    getSelectedFeaturesTableModel().loadData(features);

                } catch (DerivedGeometriesException ex) {

                    LOG.info("Error loading features", ex);

                    return;

                }

            }

        });

    }

    private void initSelectionListener() {

        ListSelectionModel selectionModel =

            getSelectedFeaturesTable().getSelectionModel();

        selectionModel.addListSelectionListener(new ListSelectionListener() {

            public void valueChanged(ListSelectionEvent e) {

                FeatureStore featureStore =

                    getParameters().getSourceLayer().getFeatureStore();

                try {

                    FeatureSelection selection =

                        (FeatureSelection) featureStore.getSelection();

                    selection.deselectAll();

                    int[] selectedRows = getSelectedIndexs();

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

                        selection.select(features.get(selectedRows[i]));

                    }

                } catch (DataException ex) {

                    LOG.info("Error selecting features", ex);

                    return;

                }

            }

        });

    }

    private void refreshDataView(DerivedGeometriesParameters parameters) {

        // Set information of summary panel

        getSourceLayerNameTextField().setText(

            parameters.getSourceLayer().getName());

        getOutputLayerNameTextField().setText(parameters.getOutPutLayerName());

        // Load features table

        FeatureStore featureStore =

            parameters.getSourceLayer().getFeatureStore();

        try {

            getAllFeaturesScrollPane().setViewportView(

                getAllFeaturesTable(featureStore));

        } catch (DerivedGeometriesException e) {

            LOG.info("Error getting feature table", e);

            return;

        }

        getSelectedFeaturesTable().setModel(

            new SelectedFeaturesTableModel(featureStore));

        getSelectedFeaturesScrollPane().setViewportView(

            getSelectedFeaturesTable());

    }

    public void setParameters(DerivedGeometriesParameters theParameters) {

        this.parameters = theParameters;

        // Refresh view with new data

        refreshDataView(parameters);

        // Initialize selection listener. We do here because

        // selectedFeaturesTable needs source layer feature store to be created

        initSelectionListener();

    }

    private void showWarningDialog() {

        String title = "_warning_adding_features";

        String message =

            "_warning_there_are_features_with_more_than_one_geometry_or_without_geometry";

        ThreadSafeDialogsManager dlgManager =

            ToolsSwingLocator.getThreadSafeDialogsManager();

        dlgManager.messageDialog(message, title, JOptionPane.WARNING_MESSAGE);

    }

    public boolean validateFields() {

        return !features.isEmpty();

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.derivedgeometries.swing.impl;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesManager;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesParameters;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesProcess;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesProcess.TYPE;

import org.gvsig.derivedgeometries.swing.api.panels.DerivedGeometriesPanel;

import org.gvsig.derivedgeometries.swing.api.panels.FeaturesControlPanel;

import org.gvsig.derivedgeometries.swing.api.panels.LayerAndProcessSelectionPanel;

import org.gvsig.derivedgeometries.swing.impl.panels.DefaultDerivedGeometriesPanel;

import org.gvsig.derivedgeometries.swing.impl.panels.DefaultFeaturesControlPanel;

import org.gvsig.derivedgeometries.swing.impl.panels.DefaultLayerAndProcessSelectionPanel;

import org.gvsig.derivedgeometries.swing.impl.processes.LineToClosedPolylineDerivedGeometriesProcess;

import org.gvsig.derivedgeometries.swing.impl.processes.PointToLineDerivedGeometriesProcess;

import org.gvsig.derivedgeometries.swing.impl.processes.PointToPolygonDerivedGeometriesProcess;

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

import org.gvsig.fmap.mapcontrol.MapControl;

public class DefaultDerivedGeometriesManager implements

    DerivedGeometriesManager {

    public DerivedGeometriesParameters createDerivedGeometriesParameters(

        MapControl mapControl, FLyrVect sourceLayer, String outputLayerName,

        String outputLayerPath, int outputLayerType, TYPE processType) {

        return new DefaultDerivedGeometriesParameters(mapControl, sourceLayer,

            outputLayerName, outputLayerPath, outputLayerType, processType);

    }

    public DerivedGeometriesParameters createDerivedGeometriesParameters() {

        return new DefaultDerivedGeometriesParameters();

    }

    public LayerAndProcessSelectionPanel getLayerAndProcessSelectionPanel(

        MapControl mapControl) {

        return new DefaultLayerAndProcessSelectionPanel(mapControl);

    }

    public FeaturesControlPanel getFeaturesControlPanel() {

        return new DefaultFeaturesControlPanel();

    }

    public DerivedGeometriesPanel getDerivedGeometriesPanel(

        MapControl mapControl) {

        return new DefaultDerivedGeometriesPanel(mapControl);

    }

    public void startDerivedGeometriesProcess(

        DerivedGeometriesParameters parameters) {

        TYPE processType = parameters.getProcessType();

        DerivedGeometriesProcess newProcess = null;

        switch (processType) {

        case POINTS_TO_LINE:

            newProcess = new PointToLineDerivedGeometriesProcess(parameters);

            break;

        case POINTS_TO_POLYGON:

            newProcess = new PointToPolygonDerivedGeometriesProcess(parameters);

            break;

        case LINES_TO_CLOSED_POLYLINE:

            newProcess =

                new LineToClosedPolylineDerivedGeometriesProcess(parameters);

            break;

        default:

            break;

        }

        newProcess.start();

    }

}

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2014 gvSIG Association

 *

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.derivedgeometries.swing.impl.processes;

import java.util.List;

import javax.swing.JOptionPane;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.derivedgeometries.swing.api.DerivedGeometriesParameters;

import org.gvsig.derivedgeometries.swing.impl.AbstractDerivedGeometriesProcess;

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

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

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.task.SimpleTaskStatus;

public class LineToClosedPolylineDerivedGeometriesProcess extends

    AbstractDerivedGeometriesProcess {

    private static final Logger logger = LoggerFactory

        .getLogger(LineToClosedPolylineDerivedGeometriesProcess.class);

    public LineToClosedPolylineDerivedGeometriesProcess(

        DerivedGeometriesParameters parameters) {

        super("Line to polyline process", parameters);

    }

    public void run() {

        SimpleTaskStatus status = null;

        try {

            status = (SimpleTaskStatus) this.getTaskStatus();

            if (status.isCancellationRequested()) {

                status.cancel();

                return;

            }

            // Get data process

            DerivedGeometriesParameters parameters = super.getParameters();

            String outputLayerName = parameters.getOutPutLayerName();

            String outputLayerPath = parameters.getOutPutLayerPath();

            int outputLayerType = parameters.getOutPutLayerType();

            boolean addLayer = parameters.getAddLayer();

            boolean createNewFeatureStore =

                parameters.getCreateNewFeatureStore();

            FLyrVect sourceLayer = parameters.getSourceLayer();

            IProjection projection = sourceLayer.getProjection();

            FeatureType sourceFeatureType =

                sourceLayer.getFeatureStore().getDefaultFeatureType();

            List<FeatureReference> selectedFeatures =

                parameters.getSelectedFeatures();

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            GeometryType sourceGeomType =

                sourceLayer.getFeatureStore().getDefaultFeatureType()

                    .getDefaultGeometryAttribute().getGeomType();

            Polygon polygon =

                geomManager.createPolygon(sourceGeomType.getSubType());

            Point vertexAnt = null;

            status.setRangeOfValues(1, selectedFeatures.size());

            // Iterate over features getting geometries to create polygon

            for (int i = 0; i < selectedFeatures.size(); i++) {

                // Si ha sido solicitada la cancelacion de la tarea

                // la marcamos como cancelada y salimos del proceso.

                if (status.isCancellationRequested()) {

                    status.cancel();

                    return;

                }

                // Informamos del progreso de la tarea

                status.setCurValue(i);

                FeatureReference featureReference = selectedFeatures.get(i);

                Geometry geom =

                    featureReference.getFeature().getDefaultGeometry();

                for (int j = 0; j < ((Curve) geom).getNumVertices(); j++) {

                    Point point = ((Curve) geom).getVertex(j);

                    if (vertexAnt == null || !vertexAnt.equals(point)) {

                        polygon.addVertex(point);

                        vertexAnt = point;

                    }

                }

            }

            // Close polygon if it is necessary

            closeSurfaceIfNecessary(polygon);

            if (status.isCancellationRequested()) {

                status.cancel();

                return;

            }

            if (createNewFeatureStore) {

                // Creating new feature store

                createNewFeatureStore(sourceFeatureType, outputLayerType,

                    outputLayerPath, projection);

                // Set createNewFeatureStore false to avoid create new feature

                // if process is started again

                parameters.setCreateNewFeatureStore(false);

            }

            // Open the new feature store

            FeatureStore featureStore = parameters.getFeatureStore();

            if (featureStore == null) {

                featureStore = getFeatureStore(outputLayerPath, projection);

            }

            // Set feature store in edit mode

            setEditingMode(featureStore);

            // Add line

            insertGeometryIntoFeauteStore(featureStore, polygon);

            // Save changes and finish editing

            endEditingMode(featureStore);

            if (status.isCancellationRequested()) {

                status.cancel();

                return;

            }

            if (addLayer) {

                // Dispose feature store to liberate resources

                featureStore.dispose();

                // Add layer to MapControl

                featureStore =

                    addLayerToMapContex(outputLayerName, outputLayerPath,

                        projection);

                parameters.setAddLayer(false);

                parameters.setFeatureStore(featureStore);

            }

            this.postProcess();

        } catch (Exception e) {

            ThreadSafeDialogsManager dlgManager =

                ToolsSwingLocator.getThreadSafeDialogsManager();

            dlgManager.messageDialog("_process_error", "_error",

                JOptionPane.ERROR_MESSAGE);

            logger.info("Error in line to closed process", e);

            if (status != null) {

                status.abort();

            }

        } finally {

            if (status != null) {

                // Mark process as terminate if it is running.

                if (status.isRunning()) {

                    status.terminate();

                }

            }

        }

    }