Application: gvSIG desktop

		List<Throwable> exs = new ArrayList<>();

_Trasladar_guiones_en_los_identificadores_a_guion_bajo=Trasladar guiones, "-", en los identificadores a guion-bajo, "_."

_Selection_of_the_geometry_field=Selecci\u00f3n del campo geometria

_Use_the_geometry_field_by_default=Usar el campo geometria por defecto

_Use_null_as_the_value_of_the_geometry=Usar null como valor para las geometrias

_Select_the_field_to_be_used_as_geometry=Seleccione el campo a usar como geometria

_Select_target_geometry_type=Seleccionar el tipo de la geometria de destino

_Type=Tipo

_Subtype=Subtipo

_Encoding=Codificaci\u00f3n

_File=Fichero

_Select_encoding=Selecci\u00f3n de codificaci\u00f3n

_Selection_of_geometry_field=Selecci\u00f3n del campo geometria

_Comprobar_la_validez_de_las_geometrias_antes_de_insertarlas=Check the validity of the geometries before inserting them

_Trasladar_guiones_en_los_identificadores_a_guion_bajo=Change hyphens, "-", in identifiers to underscores, "_".

_Selection_of_the_geometry_field=Selection of the geometry field

_Use_the_geometry_field_by_default=Use the geometry field by default

_Use_null_as_the_value_of_the_geometry=Use null as the value of the geometry

_Select_the_field_to_be_used_as_geometry=Select the field to be used as geometry

_Select_target_geometry_type=Select target geometry type

_Type=Type

_Subtype=Subtype

_Encoding=Encoding

_File=File

_Select_geometry_type=Select geometry type

_Select_encoding=Select encoding

_Selection_of_geometry_field=Selection of geometry field

        JExporttoServicePanel panel = swingManager.createExportto(

            featureStore,

            null,

            new LoadTableAction(),

            null //new int[] { ExporttoSwingManager.VECTORIAL_TABLE_WITHOUT_GEOMETRY, ExporttoSwingManager.VECTORIAL_TABLE_WITH_GEOMETRY }

        );

    @Override

import org.gvsig.exportto.swing.spi.options.ExportGeometryOptions;

import org.gvsig.exportto.swing.spi.options.ExportOptions;

    private final DefaultJExporttoServicePanel exporttoServicePanel;

    private final ExportGeometryOptions options;

    public ExportTargetProjectionWizard(

            DefaultJExporttoServicePanel exporttoServicePanel,

            ExportGeometryOptions options

        ) {

        this.options = options;

    @Override

    @Override

        this.options.setTargetProjection(this.getTargetProjection());

    @Override

    @Override

    @Override

import org.gvsig.exportto.swing.spi.options.ExportOptions;

    private final DefaultJExporttoServicePanel exporttoServicePanel;

    private final ExportOptions options;

    public ExportFilterWizard(

            DefaultJExporttoServicePanel exporttoServicePanel,

            ExportOptions options

        ) {

        this.options = options;

    @Override

    @Override

        this.options.setFilter(this.getFilter());

        this.options.setFilterExpresion(this.getFilterExpresion());

        this.options.setFilterName(this.getFilterName());

    @Override

    @Override

    @Override

import org.gvsig.exportto.swing.spi.options.ExportOptions;

    private final ExportOptions options;

            DefaultJExporttoServicePanel exporttoServicePanel,

            ExportOptions options

        ) {

        this.options = options;

        TaskStatusSwingManager TaskStatusSwingManager = ToolsSwingLocator.getTaskStatusSwingManager();

        jTaskStatus = TaskStatusSwingManager.createJTaskStatus();

    @Override

    @Override

    @Override

    @Override

    @Override

import org.gvsig.exportto.swing.spi.options.ExportGeometryOptions;

import org.gvsig.exportto.swing.spi.options.ExportOptions;

//    // Provider types that will be displayed

//    private int[] providerTypes;

    @SuppressWarnings("LeakingThisInConstructor")

    public DefaultJExporttoServicePanel(

            DefaultExporttoSwingManager uimanager,

            FeatureStore featureStore, 

            IProjection projection,

            ExporttoServiceFinishAction exporttoServiceFinishAction,

            int[] providerTypes

        ) {

//        this.providerTypes = providerTypes;

        exporterSelectionWizard = new ExporterSelectionWizard(this, providerTypes);

        // Set the listener for the finish and cancell events

        this.wizardPanelWithLogo.setWizardListener(this);

        this.initComponents();

    }

    private void initComponents() {

     * @param provider

    public void selectExporttoSwingProvider(ExporttoSwingProviderFactory provider)

        ExporttoSwingProviderManager manager = ExporttoSwingProviderLocator.getManager();

        exporttoSwingProvider = manager.createExporttoSwingProvider(

                provider.getName(), vectorLayer

        );

        ExportOptions options = this.exporttoSwingProvider.getOptions();

        if( options instanceof ExportGeometryOptions ) {

            ExportGeometryOptions geomOptions = (ExportGeometryOptions) options;

            geomOptions.setTargetProjection(projection);

            exportTargetProjectionWizard = new ExportTargetProjectionWizard(this, geomOptions);

            exportTargetProjectionWizard.setVectorLayer(vectorLayer);

        exportFilterWizard = new ExportFilterWizard(this, options);

        exporttoProgressWizard = new ExporttoProgressWizard(this, options);

        DefaultJWizardComponents wizardComponents = wizardPanelWithLogo.getWizardComponents();

            wizardPanelWithLogo.addOptionPanel(

                new DefaultWizardContainer(

                    exporttoSwingProvider.getPanelAt(i)

                )

            );

        if (exporttoSwingProvider.needsPanelTargetProjection() && exportTargetProjectionWizard!=null ){

    @Override

        private final FeatureSet featureSet;

        @Override

    @Override

    @Override

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.exportto.swing.prov.shape;

import java.io.File;

import org.gvsig.exportto.swing.spi.options.BaseExportGeometryOptions;

/**

 *

 * @author jjdelcerro

 */

public class BaseExportShapeOptions 

        extends BaseExportGeometryOptions

        implements ExportShapeOptions

    {

    private String encoding;

    private File file;

    @Override

    public String getEncoding() {

        return this.encoding;

    }

    @Override

    public void setEncoding(String encoding) {

        this.encoding = encoding;

    }

    @Override

    public File getFile() {

        return this.file;

    }

    @Override

    public void setFile(File file) {

        this.file = file;

    }

}

package org.gvsig.exportto.swing.prov.shape;

import org.gvsig.exportto.swing.prov.dbf.ExportDBFOptions;

import org.gvsig.exportto.swing.spi.options.ExportGeometryOptions;

/**

 *

 * @author jjdelcerro

 */

public interface ExportShapeOptions extends ExportDBFOptions, ExportGeometryOptions {

}

import org.gvsig.exportto.swing.prov.dbf.ExporttoDBFProvider;

import org.gvsig.exportto.swing.spi.panels.CheckGeometriesPanel;

import org.gvsig.exportto.swing.spi.panels.SelectGeometryTypePanel;

import org.gvsig.exportto.swing.spi.panels.SelectionOfTheGeometryFieldPanel;

import org.gvsig.fmap.geom.Geometry;

public class ExporttoShapeProvider extends ExporttoDBFProvider

    @SuppressWarnings("OverridableMethodCallInConstructor")

    public ExporttoShapeProvider(

        ProviderServices providerServices,

        FeatureStore featureStore,

        IProjection projection

        ) {

        super(providerServices, featureStore);

        this.getOptions().setTargetProjection(projection);

    @Override

    protected void addPanels() {

        this.panelAdd(new SelectionOfTheGeometryFieldPanel(this.getOptions()));

        this.panelAdd(new SelectGeometryTypePanel(

                this.getOptions(),

                new int[] { 

                    Geometry.TYPES.GEOMETRY,

                    Geometry.TYPES.POINT,

                    Geometry.TYPES.LINE,

                    Geometry.TYPES.POLYGON,

                    Geometry.TYPES.MULTIPOINT,

                    Geometry.TYPES.MULTILINE,

                    Geometry.TYPES.MULTIPOLYGON

                },

                new int[] {

                    Geometry.SUBTYPES.GEOM2D,

                    Geometry.SUBTYPES.GEOM3D,

                    Geometry.SUBTYPES.GEOM3DM

                } 

            )

        );

        this.panelAdd(new CheckGeometriesPanel(this.getOptions()));

        super.addPanels(); 

    }

    @Override

    public ExportShapeOptions getOptions() {

        if( this.options == null ) {

            this.options = new BaseExportShapeOptions();

        }

        return (ExportShapeOptions) this.options;

    }

    @Override

        return new ExporttoShapeService(this.getOptions());

    @Override

    public boolean needsPanelTargetProjection() {

        return true;

    }

import org.apache.commons.io.FilenameUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypesManager.Coercion;

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

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

        ExporttoService {

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

    private final AttributeNamesTranslator nameTranslator;

    private final ExportShapeOptions options;

    public ExporttoShapeService(ExportShapeOptions options) {

        this.options = options;

        this.nameTranslator = new AttributeNamesTranslator(

                this.options.getSourceFeatureType(),

        );

    @Override

    public void export(FeatureSet featureSet) throws ExporttoServiceException {

        File item_shp;

        String layer_name = FilenameUtils.getBaseName(this.options.getFile().getName());

        String pathName = FilenameUtils.removeExtension(this.options.getFile().getAbsolutePath());

        int geometryType = options.getGeometryTypeAsInt();

            String fullPathName = pathName + "_surface" + ".shp";

            item_shp = new File(fullPathName);

            export(

                    filesystemServerExplorer, 

                    newFeatureStoreParameters,

                    featureSet, 

                    Geometry.TYPES.SURFACE, 

                    true

            );

            finishAction(layer_name + " (surface)", item_shp, options.getTargetProjection());

            fullPathName = pathName + "_curve" + ".shp";

            item_shp = new File(fullPathName);

            export(

                    filesystemServerExplorer, 

                    newFeatureStoreParameters,

                    featureSet, 

                    Geometry.TYPES.CURVE, 

                    true

            );

            finishAction(layer_name + " (curve)", item_shp, options.getTargetProjection());

            fullPathName = pathName + "_point" + ".shp";

            item_shp = new File(fullPathName);

            export(

                    filesystemServerExplorer, 

                    newFeatureStoreParameters,

                    featureSet, 

                    Geometry.TYPES.POINT, 

                    true

            );

            finishAction(layer_name + " (point)", item_shp, options.getTargetProjection());

            File single_file = new File(pathName + ".shp");

            initializeParams(featureSet, single_file);

            export(

                    filesystemServerExplorer, 

                    newFeatureStoreParameters,

                    featureSet, 

                    geometryType, 

                    false

            );

            finishAction(layer_name, single_file, options.getTargetProjection());

            if (this.nameTranslator.hasTranslations()) {

                showNewNamesDialog(this.nameTranslator);

            }

        if (nameTranslator.hasTranslations()) {

            for (String source_name : nameTranslator) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    msg,

                    null,

                    Messages.getText("export_progress"),

                    JOptionPane.WARNING_MESSAGE,

                    "FieldNameTooLongInShape"

            );

    private void initializeParams(

            FeatureSet featureSet, File out_shp_file)

            throws ExporttoServiceException {

            explorerParams

                    = (FilesystemServerExplorerParameters) dataManager

                            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

        } catch (InitializeException | ProviderNotRegisteredException e) {

            filesystemServerExplorer

                    = (FilesystemServerExplorer) dataManager.openServerExplorer(

                            "FilesystemExplorer", explorerParams);

            newFeatureStoreParameters

                    = (NewFeatureStoreParameters) filesystemServerExplorer

                            .getAddParameters(out_shp_file);

        newFeatureStoreParameters.setDynValue("CRS", options.getTargetProjection());

        newFeatureStoreParameters.setDynValue("encoding", options.getEncoding());

    private void export(

            FilesystemServerExplorer explorer,

            NewFeatureStoreParameters params, 

            FeatureSet featureSet,

            int geometryType, 

            boolean checkType

        ) throws ExporttoServiceException {

            EditableFeatureType type = this.options.getSourceFeatureType().getCopy().getEditable();

            String geomFieldName = this.options.getGeometryFieldName();

            FeatureAttributeDescriptor geomFieldDescSource = (FeatureAttributeDescriptor) type.getDefaultGeometryAttribute();

            if( geomFieldDescSource!=null ) { 

                type.remove(geomFieldDescSource.getName());

            }

            EditableFeatureAttributeDescriptor geomFieldDescTarget = type.add(

                    "GEOMETRY",

                    this.options.getGeometryTypeAsInt()

            );

            geomFieldDescTarget.setDefaultValue(null);

            int gsubtype = this.options.getGeometrySubtype();

            switch (gsubtype) {

                case Geometry.SUBTYPES.GEOM2D:

                    break;

                case Geometry.SUBTYPES.GEOM3D:

                    break;

                default:

                    // Forzaremos las geometrias a 3D

                    gsubtype = Geometry.SUBTYPES.GEOM3D;

                    break;

                GeometryManager geoManager = GeometryLocator.getGeometryManager();

            geomFieldDescTarget.setGeometryType(gty);

            geomFieldDescTarget.setName(this.nameTranslator.getTargetName(geomFieldDescSource.getName()));

            geomFieldDescTarget.setPrecision(geomFieldDescSource.getPrecision());

            type.setDefaultGeometryAttributeName(geomFieldDescTarget.getName());

            FeatureStore target = (FeatureStore) manager.openStore(providerName, params);

            Geometry reproj_geom;

            EditableFeature edit_feat;

            IProjection sourceProjection

                    = options.getSourceFeatureType().getDefaultGeometryAttribute().getSRS();

            if (sourceProjection != null && sourceProjection != this.options.getTargetProjection()) {

                coord_trans = sourceProjection.getCT(this.options.getTargetProjection());

            List<Geometry> extracted;

            Geometry gitem ;

            Coercion toGeometry = ToolsLocator.getDataTypesManager()

                    .get(DataTypes.GEOMETRY).getCoercion();

                if( geomFieldName==null ) {

                    edit_feat = target.createNewFeature(true);

                    //

                    // Accumulate error in boolean.

                    // This also fixes field names (using origNameToDbfName)

                    // 

                    there_was_error = there_was_error |

                        setNonNulls(

                                options.getSourceFeatureType(),

                                targetType, 

                                feature, 

                                edit_feat

                        );

                    edit_feat.setDefaultGeometry(null);                    

                    target.insert(edit_feat);

                } else {

                    Object x = feature.getGeometry(geomFieldName);

                    try {

                        gitem = (Geometry) toGeometry.coerce(x);

                    } catch (CoercionException ex) {

                        gitem = null;

                    }

                    if (checkType) {

                        extracted = getGeometriesFrom(gitem, geometryType);

                        if (extracted.isEmpty()) {

                            // found no geometries of correct type

                            continue;

                        } else {

                            if (geometryType != Geometry.TYPES.POINT) {

                                // If not points, merge geometries

                                // (curves or surfaces)

                                try {

                                    gitem = union(extracted);

                                    extracted = new ArrayList<>();

                                    extracted.add(gitem);

                                } catch (Exception ex) {

                                    there_was_error = true;

                                    logger.info("Error in union.", ex);

                                }

                            } else {

                                // only in the case of points, we can have several

                                // geometries if source is multipoint

                    } else {

                        extracted = new ArrayList<>();

                        extracted.add(gitem);

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

                        gitem = extracted.get(i);

                        if (gsubtype == Geometry.SUBTYPES.GEOM2D) {

                            gitem = force2D(gitem, geometryType);

                        } else {

                            gitem = force3D(gitem, geometryType);

                        }

                        edit_feat = target.createNewFeature(true);

                        //

                        // Accumulate error in boolean.

                        // This also fixes field names (using origNameToDbfName)

                        // 

                        there_was_error = there_was_error |

                            setNonNulls(

                                    options.getSourceFeatureType(),

                                    targetType, 

                                    feature, 

                                    edit_feat

                            );

                        edit_feat.setDefaultGeometry(gitem);

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

                        // Reprojection stuff

                        if (coord_trans != null && gitem != null) {

                            reproj_geom = edit_feat.getDefaultGeometry();

                            reproj_geom = reproj_geom.cloneGeometry();

                            reproj_geom.reProject(coord_trans);

                            edit_feat.setDefaultGeometry(reproj_geom);

                        }

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

                        target.insert(edit_feat);

                    "_Issues_with_attributes_or_geometries");

        FeatureAttributeDescriptor[] atts = eft.getAttributeDescriptors();

        EditableFeatureAttributeDescriptor efad;

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

            String new_name = this.nameTranslator.getTargetName(atts[i].getName());

            if (new_name != null) {

                eft.remove(atts[i].getName());

                efad = eft.add(new_name, atts[i].getType(), atts[i].getSize());

                efad.setPrecision(atts[i].getPrecision());

                if (atts[i].getDataType().getType() == DataTypes.GEOMETRY) {

                    efad.setGeometryType(atts[i].getGeomType());

                }

            }

        }

    }

    /**

        if (ge == null) {

            GeometryManager geoManager = GeometryLocator.getGeometryManager();

                case Geometry.TYPES.POINT:

                    Point p = (Point) ge;

                    Point point = geoManager.createPoint(

                            p.getX(), p.getY(),

                            Geometry.SUBTYPES.GEOM2D);

                    return point;

                case Geometry.TYPES.CURVE:

                    return geoManager.createCurve(ge.getGeneralPath(), Geometry.SUBTYPES.GEOM2D);

                case Geometry.TYPES.SURFACE:

                    return geoManager.createSurface(ge.getGeneralPath(), Geometry.SUBTYPES.GEOM2D);

                default:

                    return ge;

        if (ge == null) {

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        Point point;

        switch (gt) {

                        p.getX(), p.getY(),

                        Geometry.SUBTYPES.GEOM3D);

                for (int i = 0; i < ((OrientablePrimitive) ge).getNumVertices(); i++) {

                    Point vertex = ((OrientablePrimitive) ge).getVertex(i);

                }

                ;

                for (int i = 0; i < ((OrientablePrimitive) ge).getNumVertices(); i++) {

                    Point vertex = ((OrientablePrimitive) ge).getVertex(i);

                }

                ;

        }

            FeatureType src_ft, 

            FeatureType target_ft,

            Feature feat, 

            EditableFeature edit_f

        ) {

        String orig_name;

        String dbf_name;

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

                    orig_name = atts[i].getName();

                    dbf_name = this.nameTranslator.getTargetName(orig_name);

                    if (dbf_name == null) {

                        dbf_name = orig_name;

                    }

            throws GeometryOperationNotSupportedException, GeometryOperationException {

        if ( geoms == null || geoms.isEmpty()) {

        for (int i = 1; i < geoms.size(); i++) {