/ - Diff - Application: gvSIG desktop - gvSIG

Revision 41486

+    		}
+    	}
     	public NewDataStoreParameters getAddParameters() throws DataException {
     	public DataStoreParameters getOpenParameters() throws DataException {
     		JDBCServerExplorerParameters parameters = getJDBCParameters();
     		JDBCStoreParameters params = new JDBCStoreParameters();
     		params.setHost(parameters.getHost());
     		params.setPort(parameters.getPort());
     		params.setDBName(parameters.getDBName());
     		params.setUser(parameters.getUser());
     		params.setPassword(parameters.getPassword());
     		params.setCatalog(parameters.getCatalog());
     		params.setSchema(parameters.getSchema());
     		params.setJDBCDriverClassName(parameters.getJDBCDriverClassName());
     		params.setUrl(parameters.getUrl());
     		return params;
+            }
             public NewDataStoreParameters getAddParameters() throws DataException {
     		JDBCServerExplorerParameters parameters = getJDBCParameters();
     		JDBCNewStoreParameters params = new JDBCNewStoreParameters();
     		params.setHost(parameters.getHost());
     		params.setPort(parameters.getPort());
-...
     		return NAME;
+    	}
     	protected String getStoreName() {
     	public String getStoreName() {
     		return JDBCStoreProvider.NAME;
+    	}

             "An error has been produced exporting a store";
         private static final String KEY = "_ExporttoServiceException";
         private Feature feature = null;
         protected Feature feature = null;
         /**
          * Creates a new {@link ExporttoServiceException}.
-...
             super(MESSAGE, cause, KEY, serialVersionUID);
+        }
         protected ExporttoServiceException(String message, Throwable cause, String key, long code) {
             super(message, cause, key, code);
+        }
         public ExporttoServiceException(Throwable cause, Feature feature) {
             super(MESSAGE, cause, KEY, serialVersionUID);
             this.feature = feature;

     package org.gvsig.exportto.swing.spi;
     import javax.swing.JPanel;
     import org.gvsig.tools.swing.api.Component;
     /**
      * The panels returned by a {@link ExporttoSwingProvider} have to
-...
      * @version $Id$
+     *
      */
     public abstract class ExporttoSwingProviderPanel extends JPanel {
     public interface ExporttoSwingProviderPanel extends Component {
         private static final long serialVersionUID = -342762576886358109L;
         /**
          * @return
          *         the panel title that will be displayed with
          *         this panel.
          */
         public abstract String getPanelTitle();
         public String getPanelTitle();
         /**
          * Checks if the panel is valid. If is not valid and throws
-...
          * @throws ExporttoPanelValidationException
          *             if there is any erro that has to be shown to the user.
          */
         public abstract boolean isValidPanel()
             throws ExporttoPanelValidationException;
         public boolean isValidPanel() throws ExporttoPanelValidationException;
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.exportto/org.gvsig.exportto.swing/org.gvsig.exportto.swing.impl/src/main/java/org/gvsig/exportto/swing/impl/wizard/DefaultWizardContainer.java
61	61	if (!this.exporttoSwingProviderPanel.isValidPanel()) {
62	62	throw new NotContinueWizardException(
63	63	Messages.getText("_Invalid_values_in_form"),
64		exporttoSwingProviderPanel,
	64	exporttoSwingProviderPanel.asJComponent(),
65	65	false);
66	66	}
67	67	} catch (ExporttoPanelValidationException e) {
68	68	LOG.info("Invalid form values.");
69	69	throw new NotContinueWizardException(
70	70	Messages.getText("_Invalid_values_in_form"),
71		e, exporttoSwingProviderPanel);
	71	e, exporttoSwingProviderPanel.asJComponent());
72	72	}
73	73	}
74	74
...	...
82	82	}
83	83
84	84	public JPanel getJPanel() {
85		return exporttoSwingProviderPanel;
	85	return (JPanel) exporttoSwingProviderPanel.asJComponent();
86	86	}
87	87
88	88	}

     import java.awt.BorderLayout;
     import java.awt.Component;
     import java.io.File;
     import javax.swing.JComponent;
     import javax.swing.JOptionPane;
     import javax.swing.JPanel;
-...
      * @version $Id$
+     *
      */
     public class SelectFileOptionPanel extends ExporttoSwingProviderPanel {
     public class SelectFileOptionPanel extends JPanel implements ExporttoSwingProviderPanel {
         private static final long serialVersionUID = -7417782279157857962L;
         private JPanel optionsPanel;
-...
         public JPanel getOptionsPanel() {
             return optionsPanel;
+        }
         public JComponent asJComponent() {
             return this;
+        }
+    }

      */
     package org.gvsig.exportto.swing.prov.jdbc;
     import java.util.ArrayList;
     import java.util.List;
     import org.cresques.cts.IProjection;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.exportto.ExporttoService;
     import org.gvsig.exportto.swing.prov.jdbc.panel.CheckGeometriesPanel;
     import org.gvsig.exportto.swing.prov.jdbc.panel.JDBCConnectionPanel;
     import org.gvsig.exportto.swing.prov.jdbc.panel.SelectPkPanel;
     import org.gvsig.exportto.swing.prov.jdbc.panel.SelectTableNamePanel;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProvider;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.geodb.vectorialdb.ConnectionSettings;
     import org.gvsig.fmap.dal.serverexplorer.db.DBServerExplorerParameters;
     import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;
     import org.gvsig.tools.service.spi.AbstractProvider;
     import org.gvsig.tools.service.spi.ProviderServices;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
      * Exporto provider which gets Exporto from a file.
-...
      * @version $Id$
      */
     public abstract class AbstractExporttoJDBCProvider extends AbstractProvider
         implements ExporttoSwingProvider {
         implements ExporttoJDBCProvider {
         private static Logger logger = LoggerFactory.getLogger(
             AbstractExporttoJDBCProvider.class);
         protected SelectTableNamePanel selectTableNamePanel = null;
         protected SelectPkPanel selectPkPanel = null;
         protected JDBCConnectionPanel jdbcConnectionPanel = null;
         protected List<ExporttoSwingProviderPanel> panels = new ArrayList<ExporttoSwingProviderPanel>();
         protected FeatureStore featureStore;
         protected FeatureStore sourceStore;
         protected IProjection projection;
         private final JDBCConnectionPanel connectionPanel;
         private final SelectPkPanel selectPkPanel;
         private final SelectTableNamePanel selectTableNamePanel;
         private final CheckGeometriesPanel checkGeometriesPanel;
         /**
          * Constructor.
+         *
          * @param providerServices
          *            the services for the provider
          * @param file
          *            to get the Exporto from
          */
         public AbstractExporttoJDBCProvider(ProviderServices providerServices,
             FeatureStore featureStore, IProjection projection) {
             FeatureStore sourceStore, IProjection projection) {
             super(providerServices);
             this.featureStore = featureStore;
             this.sourceStore = sourceStore;
             this.projection = projection;
             selectTableNamePanel = new SelectTableNamePanel();
             FeatureType ftype = null;
             try {
                 ftype = featureStore.getDefaultFeatureType();
                 ftype = sourceStore.getDefaultFeatureType();
             } catch (Exception exc) {
                 logger.error("While getting feature type.", exc);
                 logger.warn("Can't retrieve the feature type to use in the export to JDBC panel.", exc);
+            }
             selectPkPanel = new SelectPkPanel(ftype);
             jdbcConnectionPanel = new JDBCConnectionPanel();
             this.connectionPanel = new JDBCConnectionPanel(this);
             this.selectTableNamePanel = new SelectTableNamePanel(this);
             this.selectPkPanel = new SelectPkPanel(this,ftype);
             this.checkGeometriesPanel = new CheckGeometriesPanel(this);
             this.panels.add(this.connectionPanel);
             this.panels.add(this.selectTableNamePanel);
             this.panels.add(this.selectPkPanel);
             this.panels.add(this.checkGeometriesPanel);
+        }
         public int getPanelCount() {
             return 3;
             return this.panels.size();
+        }
         public ExporttoSwingProviderPanel getPanelAt(int index) {
             switch (index) {
             case 0:
                 return selectTableNamePanel;
             case 1:
                 return selectPkPanel;
             case 2:
                 return jdbcConnectionPanel;
+            }
             return null;
             return this.panels.get(index);
+        }
         public ExporttoService createExporttoService() {
             ConnectionSettings connectionSettings =
                 jdbcConnectionPanel.getConnectionSettings();
             JDBCServerExplorerParameters explorerParameters = this.getExplorerParameters();
             explorerParameters.setSchema(this.getSchema());
             return new ExporrtoJDBCService(
                     sourceStore,
                     explorerParameters,
                     this.getTableName(),
                     this.getPrimaryKey(),
                     this.projection,
                     this.canCreatetable(),
                     this.getGeometryChecks(),
                     this.getGeometryChecksAction()
             );
+        }
             int port = -1;
             if (connectionSettings.getPort() != null
                 && connectionSettings.getPort().length() > 0) {
                 port = Integer.valueOf(connectionSettings.getPort());
+            }
         public JDBCServerExplorerParameters getExplorerParameters() {
             return this.connectionPanel.getServerExplorerParameters();
+        }
         public String getSchema() {
             return this.selectTableNamePanel.getSchema();
+        }
             String schema = null;
             if (connectionSettings.getSchema() != null
                 && connectionSettings.getSchema().length() > 0) {
                 schema = connectionSettings.getSchema();
+            }
         public String getTableName() {
             return this.selectTableNamePanel.getTableName();
+        }
             return new ExporrtoJDBCService(featureStore,
                 connectionSettings.getDb(), schema, selectTableNamePanel.getText(),
                 selectPkPanel.getText(), connectionSettings.getUser(),
                 connectionSettings.getPassw(), connectionSettings.getHost(), port,
                 getExplorerName(), getStoreName(), this.projection);
         public boolean canCreatetable() {
             return this.selectTableNamePanel.canCreateTable();
+        }
         public abstract String getStoreName();
         public String getPrimaryKey() {
             return this.selectPkPanel.getPrimaryKeyName();
+        }
         public abstract String getExplorerName();
         public int getGeometryChecks() {
             return this.checkGeometriesPanel.getGeometryChecks();
+        }
         public int getGeometryChecksAction() {
             return this.checkGeometriesPanel.getGeometryChecksAction();
+        }
         public String getExplorerName() {
             return this.connectionPanel.getServerExplorerParameters().getExplorerName();
+        }
+    }

+     *
      * Copyright (C) 2007-2013 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 3
      * of the License, or (at your option) any later version.
      * 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 3 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.
      * 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.
      * 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.
      * 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.exportto.swing.prov.jdbc;
     import java.util.Iterator;
     import org.cresques.cts.ICoordTrans;
     import org.cresques.cts.IProjection;
     import org.gvsig.exportto.ExporttoService;
     import org.gvsig.exportto.ExporttoServiceException;
     import org.gvsig.exportto.ExporttoServiceFinishAction;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.InitializeException;
     import org.gvsig.fmap.dal.exception.OpenException;
     import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;
     import org.gvsig.fmap.dal.exception.ValidateDataParametersException;
     import org.gvsig.fmap.dal.feature.EditableFeature;
     import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.EditableFeatureType;
-...
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.NewFeatureStoreParameters;
     import org.gvsig.fmap.dal.store.db.DBStoreParameters;
     import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;
     import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;
     import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;
     import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.service.ServiceException;
     import org.gvsig.tools.task.AbstractMonitorableTask;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
+     *
      */
     public class ExporrtoJDBCService extends AbstractMonitorableTask implements
         ExporttoService {
             ExporttoService {
         private static final DataManager DATA_MANAGER = DALLocator.getDataManager();
         public static final int CHECK_NONE = 0;
         public static final int CHECK_IF_CORRUPT = 1;
         public static final int CHECK_IF_VALID = 2;
         private String dbName = null;
         private String schema = null;
         private String tableName = null;
         private String pkField = null;
         private String userName = null;
         private String password = null;
         private String host = null;
         private int port = -1;
         private String explorerName = null;
         private String storeName = null;
         public static final int ACTION_SET_GEOMETRY_TO_NULL = 0;
         public static final int ACTION_SKIP_FEATURE = 1;
         public static final int ACTION_ABORT = 2;
         private NewFeatureStoreParameters newFeatureStoreParameters;
         private JDBCServerExplorer explorer;
         private FeatureStore featureStore;
         private IProjection targetProjection;
         private final FeatureStore source;
         private final JDBCServerExplorerParameters explorerParameters;
         private final String tableName;
         private final String pkname;
         private final int geometryChecks;
         private final int geometryChecksAction;
         private final IProjection tarjetProjection;
         private final boolean canCreateTable;
         private ExporttoServiceFinishAction exporttoServiceFinishAction = null;
         /**
          * @param taskName
          * @throws ServiceException
          */
         protected ExporrtoJDBCService(FeatureStore featureStore, String dbName,
             String schema, String tableName, String pkField, String userName,
             String password, String host, int port, String explorerName,
             String storeName, IProjection target_projetion) {
             super("Export to JDBC");
             this.featureStore = featureStore;
             this.dbName = dbName;
             this.schema = schema;
             this.tableName = tableName;
             this.pkField = pkField;
             this.userName = userName;
             this.password = password;
             this.host = host;
             this.port = port;
             this.storeName = storeName;
             this.explorerName = explorerName;
             this.targetProjection = target_projetion;
         public ExporrtoJDBCService(FeatureStore source,
                 JDBCServerExplorerParameters explorerParameters,
                 String tablename,
                 String primaryKeyName,
                 IProjection tarjetProjection,
                 boolean canCreatetable,
                 int geometryChecks,
                 int geometryChecksAction) {
             this.source = source;
             this.explorerParameters = explorerParameters;
             this.tableName = tablename;
             this.pkname = primaryKeyName;
             this.tarjetProjection = tarjetProjection;
             this.canCreateTable = canCreatetable;
             this.geometryChecks = geometryChecks;
             this.geometryChecksAction = geometryChecksAction;
+        }
         public void export(FeatureSet featureSet) throws ExporttoServiceException {
         protected void createTable(JDBCServerExplorer explorer) throws Exception {
             initializeParams(featureSet);
             FeatureType targetFeatureType ;
             EditableFeatureType targetEditableFeatureType ;
             DisposableIterator it1 = null;
             targetFeatureType = source.getDefaultFeatureType().getCopy();
             targetEditableFeatureType = targetFeatureType.getEditable();
             if (this.pkname != null) {
                 EditableFeatureAttributeDescriptor pk
                         = targetEditableFeatureType.add(this.pkname, DataTypes.LONG);
                 pk.setIsPrimaryKey(true);
                 pk.setIsAutomatic(true);
+            }
             // ======================================================
             // Reprojection: set SRS of geometry field to target SRS
             EditableFeatureAttributeDescriptor attrdescriptor
                     = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.getDefaultGeometryAttribute();
             if (attrdescriptor != null) {
                 attrdescriptor.setSRS(this.tarjetProjection);
+            }
             // ======================================
             NewFeatureStoreParameters createTableParams = (NewFeatureStoreParameters) explorer.getAddParameters();
             createTableParams.setDefaultFeatureType(targetEditableFeatureType);
             explorer.add(explorer.getStoreName(), createTableParams, true);
+        }
         private static class InvalidGeometryException extends ExporttoServiceException {
             public InvalidGeometryException(Feature feature, String checkMessage) {
                 super(checkMessage, null, checkMessage, 0);
                 this.feature = feature;
+            }
+        }
         public void export(FeatureSet featureSet) throws ExporttoServiceException {
             Geometry.ValidationStatus geometryCheck;
             DisposableIterator it = null;
             EditableFeature targetFeature = null;
             FeatureStore target = null;
             EditableFeatureType ef_type = null;
             FeatureType f_type = null;
             EditableFeature edit_feat = null;
             try {
                 f_type = featureStore.getDefaultFeatureType();
                 f_type = f_type.getCopy();
                 ef_type = f_type.getEditable();
                 if (pkField != null) {
                     EditableFeatureAttributeDescriptor pk =
                         ef_type.add(pkField, DataTypes.LONG);
                     pk.setIsPrimaryKey(true);
                     pk.setIsAutomatic(true);
+                }
                 // ========================================
                 // Reprojection: set SRS of geometry field to
                 // target SRS
                 EditableFeatureAttributeDescriptor eatt =
                     (EditableFeatureAttributeDescriptor)
                     ef_type.getDefaultGeometryAttribute();
                 if (eatt != null) {
                     eatt.setSRS(this.targetProjection);
+                }
                 // ======================================
                 newFeatureStoreParameters.setDefaultFeatureType(ef_type);
                 explorer.add(storeName, newFeatureStoreParameters, true);
                 // ======================================
                 // Reprojection
                 FeatureAttributeDescriptor geo_att = f_type.getDefaultGeometryAttribute();
                 FeatureAttributeDescriptor geo_att = source.getDefaultFeatureType().getDefaultGeometryAttribute();
                 IProjection sourceProjection = null;
                 ICoordTrans coord_trans = null;
                 Geometry reproj_geom = null;
                 if (geo_att != null) {
                     sourceProjection = geo_att.getSRS();
                     // this comparison is perhaps too preventive
                     // we could  have two instances of same projection
                     // so we would do more computations than needed
                     if (sourceProjection != this.targetProjection) {
                         coord_trans = sourceProjection.getCT(this.targetProjection);
                     if (sourceProjection != this.tarjetProjection) {
                         coord_trans = sourceProjection.getCT(this.tarjetProjection);
+                    }
+                }
                 // ============================================
                 target =
                     (FeatureStore) DATA_MANAGER.openStore(
                     		storeName,
                     		newFeatureStoreParameters);
                 FeatureType targetType = target.getDefaultFeatureType();
                 DataManager dataManager = DALLocator.getDataManager();
                 JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(
                         this.explorerParameters.getExplorerName(),
                         this.explorerParameters
                 );
                 if (this.canCreateTable) {
                     this.createTable(explorer);
+                }
                 JDBCStoreParameters openParams = (JDBCStoreParameters) explorer.getOpenParameters();
                 openParams.setTable(this.tableName);
                 openParams.setCRS(this.tarjetProjection);
                 openParams.setDefaultGeometryField(
                         source.getDefaultFeatureType().getDefaultGeometryAttributeName()
                 );
                 target = (FeatureStore) explorer.open(openParams);
                 FeatureType targetFeatureType = target.getDefaultFeatureType();
                 target.edit(FeatureStore.MODE_APPEND);
                 taskStatus.setRangeOfValues(0, featureSet.getSize());
                 int featureCount = 1;
                 it1 = featureSet.fastIterator();
                 Geometry reproj_geom = null;
                 while (it1.hasNext()) {
                     Feature feature = (Feature) it1.next();
                     edit_feat = target.createNewFeature(targetType, feature);
                 taskStatus.setRangeOfValues(0, featureSet.getSize());
                 it = featureSet.fastIterator();
                 while (it.hasNext()) {
                     Feature feature = (Feature) it.next();
                     targetFeature = target.createNewFeature(targetFeatureType, feature);
                     Geometry geometry = targetFeature.getDefaultGeometry();
                     switch (this.geometryChecks) {
                         case CHECK_IF_CORRUPT:
                             geometryCheck = geometry.getValidationStatus();
                             if (geometryCheck.getStatusCode() == Geometry.ValidationStatus.CURRUPTED) {
                                 switch (this.geometryChecksAction) {
                                     case ACTION_SET_GEOMETRY_TO_NULL:
                                         targetFeature.setDefaultGeometry(null);
                                         break;
                                     case ACTION_SKIP_FEATURE:
                                         continue;
                                     case ACTION_ABORT:
                                     default:
                                         throw new InvalidGeometryException(targetFeature, geometryCheck.getMessage());
+                                }
+                            }
                             break;
                         case CHECK_IF_VALID:
                             geometryCheck = geometry.getValidationStatus();
                             if (!geometryCheck.isValid()) {
                                 switch (this.geometryChecksAction) {
                                     case ACTION_SET_GEOMETRY_TO_NULL:
                                         targetFeature.setDefaultGeometry(null);
                                         break;
                                     case ACTION_SKIP_FEATURE:
                                         continue;
                                     case ACTION_ABORT:
                                     default:
                                         throw new InvalidGeometryException(targetFeature, geometryCheck.getMessage());
+                                }
+                            }
                             break;
                         case CHECK_NONE:
                         default:
                             break;
+                    }
                     // ================================================
                     // Reprojection
                     if (geo_att != null && coord_trans != null) {
                         reproj_geom = edit_feat.getDefaultGeometry();
                         reproj_geom = targetFeature.getDefaultGeometry();
                         reproj_geom = reproj_geom.cloneGeometry();
                         reproj_geom.reProject(coord_trans);
                         edit_feat.setDefaultGeometry(reproj_geom);
                         targetFeature.setDefaultGeometry(reproj_geom);
+                    }
                     // ================================================
                     target.insert(edit_feat);
                     target.insert(targetFeature);
                     this.taskStatus.setCurValue(featureCount);
                     if (this.taskStatus.isCancellationRequested()) {
-...
+                    }
                     featureCount++;
+                }
                 edit_feat = null;
                 targetFeature = null;
                 target.finishEditing();
                 /*
                  * Creating normal parameters (not "new store parameters")
                  * to add layer
                  */
                 String storename = newFeatureStoreParameters.getDataStoreName();
                 JDBCStoreParameters params = getParams(explorer, tableName, schema, storename);
                 if (geo_att != null) {
                     params.setCRS(targetProjection);
                     params.setDefaultGeometryField(targetType.getDefaultGeometryAttributeName());
+                }
                 if (exporttoServiceFinishAction != null) {
                     exporttoServiceFinishAction.finished(
                         tableName + " (" + storename + ")",
                         params);
                             this.tableName + " (" + explorer.getStoreName() + ")",
                             openParams);
+                }
             } catch (Exception e) {
                 taskStatus.message(e.getMessage());
                 throw new ExporttoServiceException(e,edit_feat);
                 throw new ExporttoServiceException(e, targetFeature);
             } finally {
                 if (it1 != null) {
                     it1.dispose();
                 if (it != null) {
                     it.dispose();
+                }
                 featureSet.dispose();
                 if (target != null) {
-...
+            }
+        }
         private JDBCStoreParameters getParams(
         		JDBCServerExplorer explo,
         		String tab, String sche, String storename) throws DataException {
         	Iterator iter = explo.list().iterator();
         	JDBCStoreParameters item = null;
         	while (iter.hasNext()) {
         		item = (JDBCStoreParameters) iter.next();
         		if (item.getTable().compareTo(tab) == 0
         				&&
         				(sche == null || item.getSchema().compareTo(sche) == 0)) {
         			return item;
+        		}
+        	}
         	throw new OpenException(storename, new Exception("Table not found: " + tab));
+    	}
     	private void initializeParams(FeatureSet featureSet)
             throws ExporttoServiceException {
             JDBCServerExplorerParameters explorerParam;
             try {
                 explorerParam =
                     (JDBCServerExplorerParameters) DATA_MANAGER
                         .createServerExplorerParameters(explorerName);
                 explorerParam.setHost(host);
                 if (port > -1) {
                     explorerParam.setPort(port);
+                }
                 explorerParam.setDBName(dbName);
                 explorerParam.setUser(userName);
                 explorerParam.setPassword(password);
                 if (schema != null && schema.length() > 0) {
                     explorerParam.setSchema(schema);
+                }
                 explorer =
                     (JDBCServerExplorer) DATA_MANAGER.openServerExplorer(
                         explorerName, explorerParam);
                 newFeatureStoreParameters =
                     (NewFeatureStoreParameters) explorer.getAddParameters();
                 ((DBStoreParameters) newFeatureStoreParameters).setTable(tableName);
                 ((DBStoreParameters) newFeatureStoreParameters)
                     .setDefaultGeometryField(featureSet.getDefaultFeatureType()
                         .getDefaultGeometryAttributeName());
             } catch (InitializeException e) {
                 throw new ExporttoServiceException(e);
             } catch (ProviderNotRegisteredException e) {
                 throw new ExporttoServiceException(e);
             } catch (ValidateDataParametersException e) {
                 throw new ExporttoServiceException(e);
             } catch (DataException e) {
                 throw new ExporttoServiceException(e);
+            }
+        }
         public void setFinishAction(
             ExporttoServiceFinishAction exporttoServiceFinishAction) {
                 ExporttoServiceFinishAction exporttoServiceFinishAction) {
             this.exporttoServiceFinishAction = exporttoServiceFinishAction;
+        }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 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 3
      * 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.exportto.swing.prov.jdbc.panel;
     import java.awt.BorderLayout;
     import javax.swing.JTextField;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public abstract class AbstractSelectTextPanel extends
         ExporttoSwingProviderPanel {
         private static final long serialVersionUID = -6179384073023096591L;
         protected JTextField textField = null;
         public AbstractSelectTextPanel() {
             super();
             initializeComponents();
+        }
         protected void initializeComponents() {
             this.setLayout(new BorderLayout());
             textField = new JTextField();
             add(textField, BorderLayout.NORTH);
+        }
         public String getText() {
             String field = textField.getText();
             if ((field == null) || (field.equals(""))) {
                 return null;
+            }
             return field;
+        }
+    }

      */
     package org.gvsig.exportto.swing.prov.jdbc.panel;
     import java.awt.BorderLayout;
     import java.util.ArrayList;
     import java.util.Iterator;
     import java.util.List;
     import javax.swing.JComponent;
     import javax.swing.JPanel;
     import org.gvsig.exportto.swing.prov.jdbc.ExporttoJDBCProvider;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.gvsig.exportto.swing.ExporttoSwingLocator;
     import org.gvsig.exportto.swing.ExporttoSwingManager;
     import org.gvsig.exportto.swing.spi.ExporttoPanelValidationException;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.DataServerExplorerParameters;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.ValidateDataParametersException;
     import org.gvsig.fmap.dal.serverexplorer.db.DBServerExplorerParameters;
     import org.gvsig.geodb.vectorialdb.ConnectionPanel;
     import org.gvsig.geodb.vectorialdb.ConnectionSettings;
     import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.i18n.I18nManager;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class JDBCConnectionPanel extends ExporttoSwingProviderPanel {
     public class JDBCConnectionPanel extends JPanel implements ExporttoSwingProviderPanel {
         private static final long serialVersionUID = -3278172717881233447L;
         private static final Logger LOG = LoggerFactory
             .getLogger(JDBCConnectionPanel.class);
         private static final Logger LOG = LoggerFactory.getLogger(JDBCConnectionPanel.class);
         private DBConnectionPanel connectionPanel = null;
         private final ExporttoJDBCProvider provider;
         private static final DataManager DATA_MANAGER = DALLocator.getDataManager();
         private static final ExporttoSwingManager EXPORTTO_SWING_MANAGER =
             ExporttoSwingLocator.getSwingManager();
         private org.gvsig.geodb.vectorialdb.ConnectionPanel connectionPanel = null;
         public JDBCConnectionPanel() {
             super();
             initializeComponents();
         public JDBCConnectionPanel(ExporttoJDBCProvider provider) {
             this.provider = provider;
             initComponents();
+        }
         private void initializeComponents() {
             this.setLayout(new BorderLayout());
             connectionPanel = new ConnectionPanel();
             add(connectionPanel, BorderLayout.CENTER);
             initialiceExplorers();
         private void initComponents() {
             this.connectionPanel = new DBConnectionPanel();
+        }
         @SuppressWarnings("rawtypes")
         private void initialiceExplorers() {
             List explorers = DATA_MANAGER.getExplorerProviders();
             Iterator iter = explorers.iterator();
             DataServerExplorerParameters exParam = null;
             String name;
             List<String> dbExplores = new ArrayList<String>(explorers.size());
             while (iter.hasNext()) {
                 name = (String) iter.next();
                 try {
                     exParam = DATA_MANAGER.createServerExplorerParameters(name);
                 } catch (DataException e) {
                     LOG.error("Error initilializing the explorer", e);
+                }
                 if (exParam instanceof DBServerExplorerParameters) {
                     dbExplores.add(name);
+                }
+            }
             connectionPanel.setDrivers(dbExplores.toArray(new String[dbExplores
                 .size()]));
         public JDBCServerExplorerParameters getServerExplorerParameters() {
             return this.connectionPanel.getServerExplorerParameters();
+        }
         @Override
         public String getPanelTitle() {
             return EXPORTTO_SWING_MANAGER.getTranslation("connection_params");
             I18nManager i18nManager = ToolsLocator.getI18nManager();
             return i18nManager.getTranslation("connection_params");
+        }
         @Override
         public boolean isValidPanel() throws ExporttoPanelValidationException {
             // ConnectionSettings connectionSettings = getConnectionSettings();
             // Check parameters...
             return true;
             DBServerExplorerParameters connection = this.connectionPanel.getConnection();
             try {
                 connection.validate();
                 return true;
             } catch (ValidateDataParametersException ex) {
                 throw new ExporttoPanelValidationException(ex.getMessageStack(),ex);
             } catch(Exception ex) {
                 return false;
+            }
+        }
         public ConnectionSettings getConnectionSettings() {
             return connectionPanel.getConnectionSettings();
         public JComponent asJComponent() {
             return this.connectionPanel;
+        }
+    }

+     *
      * Copyright (C) 2007-2013 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 3
      * of the License, or (at your option) any later version.
      * 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 3 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.
      * 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.
      * 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.
      * 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.exportto.swing.prov.jdbc.panel;
     import org.gvsig.exportto.swing.ExporttoSwingLocator;
     import org.gvsig.exportto.swing.ExporttoSwingManager;
     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import java.util.Iterator;
     import java.util.List;
     import javax.swing.DefaultListModel;
     import javax.swing.JComponent;
     import javax.swing.JOptionPane;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.exportto.swing.prov.jdbc.ExporttoJDBCProvider;
     import org.gvsig.exportto.swing.spi.ExporttoPanelValidationException;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataManager;
     import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorer;
     import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;
     import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.i18n.I18nManager;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
+     *
      */
     public class SelectTableNamePanel extends AbstractSelectTextPanel {
     public class SelectTableNamePanel extends SelectTableNamePanelLayout implements ExporttoSwingProviderPanel {
         private static final Logger logger = LoggerFactory.getLogger(SelectTableNamePanel.class);
         private static final long serialVersionUID = 6269512983586358017L;
         private final ExporttoJDBCProvider provider;
         private static final ExporttoSwingManager EXPORTTO_SWING_MANAGER =
             ExporttoSwingLocator.getSwingManager();
         private static class TableItem {
         @Override
             private JDBCStoreParameters params;
             private String label;
             public TableItem(String label, JDBCStoreParameters params) {
                 this.params = params;
                 this.label = label;
+            }
             public TableItem(JDBCStoreParameters params) {
                 this(params.getSchema() + "." + params.getTable(), params);
+            }
             public String toString() {
                 return this.label;
+            }
             public JDBCStoreParameters getParams() {
                 return this.params;
+            }
+        }
         public SelectTableNamePanel(ExporttoJDBCProvider provider) {
             this.provider = provider;
+        }
         private void initComponents() {
             this.rdoCreateTable.addActionListener(new ActionListener() {
                 public void actionPerformed(ActionEvent e) {
                     onChangeRadioSelecion();
+                }
             });
             this.rdoInsert.addActionListener(new ActionListener() {
                 public void actionPerformed(ActionEvent e) {
                     onChangeRadioSelecion();
+                }
             });
             this.fillTablesList();
+        }
         public boolean canCreateTable() {
             return this.rdoCreateTable.isSelected();
+        }
         public String getSchema() {
             if (this.canCreateTable()) {
                 return StringUtils.defaultIfBlank(this.txtSchema.getText(), null);
+            }
             JDBCStoreParameters table = (JDBCStoreParameters) this.lstTables.getSelectedValue();
             if( table == null ) {
                 return null;
+            }
             return table.getSchema();
+        }
         public String getTableName() {
             if (this.canCreateTable()) {
                 return StringUtils.defaultIfBlank(this.txtSchema.getText(), null);
+            }
             JDBCStoreParameters table = (JDBCStoreParameters) this.lstTables.getSelectedValue();
             if( table == null ) {
                 return null;
+            }
             return table.getTable();
+        }
         public String getPanelTitle() {
             return EXPORTTO_SWING_MANAGER.getTranslation("intro_tablename");
             I18nManager i18nManager = ToolsLocator.getI18nManager();
             return i18nManager.getTranslation("intro_tablename");
+        }
         @Override
         public boolean isValidPanel() throws ExporttoPanelValidationException {
             if (getText() == null || getText().equals("")) {
             if (this.getTableName() == null) {
                 throw new ExporttoPanelValidationException(
                     "The table cannot be empty");
                         "The table cannot be empty");
+            }
             if (this.getSchema() == null) {
                 throw new ExporttoPanelValidationException(
                         "The schema cannot be empty");
+            }
             return true;
+        }
         public JComponent asJComponent() {
             return this;
+        }
         public void onChangeRadioSelecion() {
             if (this.rdoCreateTable.isSelected()) {
                 this.txtSchema.setEnabled(true);
                 this.txtTableName.setEnabled(true);
                 this.lstTables.setEnabled(false);
             } else {
                 this.txtSchema.setEnabled(false);
                 this.txtTableName.setEnabled(false);
                 this.lstTables.setEnabled(true);
+            }
+        }
         private void fillTablesList() {
             JDBCServerExplorerParameters explorerParameters = this.provider.getExplorerParameters();
             if (explorerParameters == null) {
                 return;
+            }
             DefaultListModel lmodel = new DefaultListModel();
             DataManager dataManager = DALLocator.getDataManager();
             try {
                 JDBCServerExplorer explorer = (JDBCServerExplorer) dataManager.openServerExplorer(
                         explorerParameters.getExplorerName(),
                         explorerParameters
                 );
                 List<JDBCStoreParameters> tables = explorer.list();
                 Iterator<JDBCStoreParameters> it = tables.iterator();
                 while (it.hasNext()) {
                     JDBCStoreParameters table = it.next();
                     lmodel.addElement(new TableItem(table));
+                }
             } catch (Exception ex) {
                 I18nManager i18nManager = ToolsLocator.getI18nManager();
                 logger.warn("Can't retrive the list of tables of "+explorerParameters.toString(),ex);
                 JOptionPane.showMessageDialog(
                         this,
                         i18nManager.getTranslation("_Cant_retrive_tables_information"),
                         i18nManager.getTranslation("_Warning"),
                         JOptionPane.WARNING_MESSAGE
                 );
+            }
+        }
+    }

      */
     package org.gvsig.exportto.swing.prov.jdbc.panel;
     import java.awt.BorderLayout;
     import java.awt.event.ActionEvent;
     import java.awt.event.ActionListener;
     import javax.swing.JComponent;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.exportto.swing.prov.jdbc.ExporttoJDBCProvider;
     import javax.swing.JLabel;
     import javax.swing.JPanel;
     import javax.swing.JTextField;
     import org.gvsig.exportto.swing.ExporttoSwingLocator;
     import org.gvsig.exportto.swing.ExporttoSwingManager;
     import org.gvsig.exportto.swing.spi.ExporttoPanelValidationException;
     import org.gvsig.exportto.swing.spi.ExporttoSwingProviderPanel;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.i18n.I18nManager;
     /**
      * @author gvSIG Team
      * @version $Id$
+     *
      */
     public class SelectPkPanel extends AbstractSelectTextPanel {
     public class SelectPkPanel extends SelectPkPanelLayout implements ExporttoSwingProviderPanel {
         private static final long serialVersionUID = 2652404227373508779L;
         private static final ExporttoSwingManager EXPORTTO_SWING_MANAGER =
             ExporttoSwingLocator.getSwingManager();
         private FeatureType featType = null;
         private ExporttoJDBCProvider provider;
         public SelectPkPanel() {
             super();
         public SelectPkPanel(ExporttoJDBCProvider provider) {
             this.provider = provider;
+        }
         public SelectPkPanel(FeatureType ft) {
             super();
         public SelectPkPanel(ExporttoJDBCProvider provider,FeatureType ft) {
             this(provider);
             featType = ft;
+        }
         protected void initializeComponents() {
             this.setLayout(new BorderLayout());
         protected void initComponents() {
             this.chkCreatePrimaryKey.addActionListener(new ActionListener() {
                 public void actionPerformed(ActionEvent e) {
                     onChangeCreatePrimaryKey();
+                }
             });
             this.translateControls();
+        }
         private void onChangeCreatePrimaryKey() {
             this.txtPrimaryKeyName.setEnabled(this.chkCreatePrimaryKey.isSelected());
+        }
         protected void translateControls() {
             I18nManager i18nManager = ToolsLocator.getI18nManager();
             JPanel topPanel = new JPanel(new BorderLayout());
             textField = new JTextField();
             String msg = EXPORTTO_SWING_MANAGER.getTranslation(
                 "_Enter_new_field_name_for_primary_key_or_blank_to_not_add_primary_key");
             topPanel.add(new JLabel(msg + ":"), BorderLayout.NORTH);
             topPanel.add(textField, BorderLayout.CENTER);
             // ==============================================
             add(topPanel, BorderLayout.NORTH);
+        }
         public String getText() {
             String field = textField.getText();
             if ((field == null) || (field.trim().equals(""))) {
         public String getPrimaryKeyName() {
             if( !this.chkCreatePrimaryKey.isSelected() ) {
                 return null;
+            }
             return field;
             String pkname = this.txtPrimaryKeyName.getText();
             if( StringUtils.isBlank(pkname) ) {
                 return null;
+            }
             return pkname.trim();
+        }
         @Override
         public String getPanelTitle() {
             return EXPORTTO_SWING_MANAGER.getTranslation("_Primary_key");
             I18nManager i18nManager = ToolsLocator.getI18nManager();
             return i18nManager.getTranslation("_Primary_key");
+        }
         @Override
         public boolean isValidPanel() throws ExporttoPanelValidationException {
             String txt = this.getText();
             if (isFieldName(txt, featType)) {
             String pkname = this.getPrimaryKeyName();
             if (isFieldName(pkname, this.featType)) {
                 I18nManager i18nManager = ToolsLocator.getI18nManager();
                 throw new ExporttoPanelValidationException(
                     EXPORTTO_SWING_MANAGER.getTranslation(
                     "_Field_name_already_exists"));
                     i18nManager.getTranslation("_Field_name_already_exists"));
+            }
             return true;
+        }
         private boolean isFieldName(String txt, FeatureType ft) {
             if (ft == null || txt == null) {
         private boolean isFieldName(String name, FeatureType ft) {
             if (ft == null || name == null) {
                 return false;
+            }
             FeatureAttributeDescriptor[] atts = ft.getAttributeDescriptors();
             for (int i=0; i<atts.length; i++) {
                 if (atts[i].getName().equals(txt)) {
                 if (atts[i].getName().equalsIgnoreCase(name)) {
                     return true;
+                }
+            }
             return false;
+        }
         public JComponent asJComponent() {
             return this;
+        }
+    }

         /**
          * Constructor.
+         *
          * @param providerServices
          *            the services for the provider
          * @param file
          *            to get the Exporto from
          */
         public ExporttoPostgreSQLProvider(ProviderServices providerServices,
             FeatureStore featureStore, IProjection projection) {

      */
     package org.gvsig.exportto.swing.prov.generic.panel;
     import javax.swing.JComponent;
     import javax.swing.JPanel;
     import org.gvsig.exportto.swing.ExporttoSwingLocator;
     import org.gvsig.exportto.swing.ExporttoSwingManager;
     import org.gvsig.exportto.swing.prov.generic.ExporttoGenericProvider;
-...
      * @version $Id$
+     *
      */
     public abstract class AbstractExporttoGenericPanel extends
     public abstract class AbstractExporttoGenericPanel extends JPanel implements
         ExporttoSwingProviderPanel {
         private static final long serialVersionUID = -7994157431819798158L;
-...
             super();
             this.exporttoGenericProvider = exporttoGenericProvider;
+        }
         public JComponent asJComponent() {
             return this;
+        }
+    }

Also available in: Unified diff