Application: gvSIG desktop

package org.gvsig.export.impl;

import java.util.List;

import java.util.Objects;

import javax.swing.JOptionPane;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.export.ExportException;

import org.gvsig.export.ExportLocator;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.ExportParametersGeometry;

import org.gvsig.export.ExportProcess;

import org.gvsig.export.spi.ExportService;

import org.gvsig.export.spi.ExportServiceFactory;

import org.gvsig.export.spi.ExportServiceManager;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

import org.gvsig.tools.ToolsLocator;

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

import org.gvsig.tools.task.TaskStatus;

/**

 *

 * @author jjdelcerro

 */

public class DefaultExportProcess

        implements ExportProcess {

    private ExportServiceFactory factory;

    private ExportService service;

    private ExportParameters parameters;

    private FeatureStore sourceFeatureStore;

    private IProjection contextProjection;

    private ICoordTrans sourceTransformation;

    private IProjection sourceProjection;

    private Object context;

    private Expression filterExpression;

    private int featuresToUse;

//    private AttributeNamesTranslator attributeNamesTranslator;

    public DefaultExportProcess() {

    }

    @Override

    public void setOutputFormat(String serviceName) throws ExportException {

        ExportServiceManager serviceManager = ExportLocator.getServiceManager();

        this.factory = serviceManager.getServiceFactory(serviceName);

        this.parameters = this.factory.createParameters();

        this.service = this.factory.createService(this.parameters);

        this.parameters.setSourceFeatureStore(this.sourceFeatureStore);

        if (this.parameters instanceof ExportParametersGeometry) {

            ExportParametersGeometry params = (ExportParametersGeometry) this.parameters;

            params.setContextProjection(this.contextProjection);

            params.setSourceProjection(this.sourceProjection);

            params.setSourceTransformation(this.sourceTransformation);

            params.setContext(this.context);

        }

        this.parameters.setFilterExpresion(this.filterExpression);

        this.parameters.setFeaturesToUse(this.featuresToUse); //valor que use la expression si no es nula

    }

    @Override

    public void setParameters(ExportParameters params) {

        this.parameters = params;

        this.factory = this.parameters.getFactory();

        this.service = this.factory.createService(this.parameters);

        this.parameters.setSourceFeatureStore(this.sourceFeatureStore);

        this.parameters.setContext(this.context);

        this.featuresToUse = this.parameters.getFeaturesToUse();

        if (Objects.equals(this.filterExpression, this.parameters.getFilterExpresion())) {

            int keepFilter = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(

                    ToolsLocator.getI18nManager().getTranslation("_Do_you_want_to_keep_the_applied_filter_and_not_use_the_one_in_the_parameters"),

                    ToolsLocator.getI18nManager().getTranslation("_Filter_to_apply"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.WARNING_MESSAGE,

                    "exporto-overwrite-expression-parameters");

            if (keepFilter == JOptionPane.YES_OPTION) {

                this.parameters.setFilterExpresion(this.filterExpression);

            } else {

                this.filterExpression = this.parameters.getFilterExpresion();

            }

        } else {

            this.filterExpression = this.parameters.getFilterExpresion();

        }

        if (this.parameters instanceof ExportParametersGeometry) {

            ExportParametersGeometry pa = (ExportParametersGeometry) this.parameters;

            this.contextProjection = pa.getContextProjection();

            this.sourceProjection = pa.getSourceProjection();

            this.sourceTransformation = pa.getSourceTransformation();

        }

    }

    @Override

    public void setSourceFeatureStore(FeatureStore store

    ) {

        this.sourceFeatureStore = store;

        if (this.parameters != null) {

            this.parameters.setSourceFeatureStore(sourceFeatureStore);

        }

    }

    @Override

    public void setContextProjection(IProjection projection

    ) {

        this.contextProjection = projection;

        if (this.parameters instanceof ExportParametersGeometry) {

            ((ExportParametersGeometry) this.parameters).setContextProjection(projection);

        }

    }

    @Override

    public void setSourceTransformation(ICoordTrans transformation

    ) {

        this.sourceTransformation = transformation;

        if (this.parameters instanceof ExportParametersGeometry) {

            ((ExportParametersGeometry) this.parameters).setSourceTransformation(transformation);

        }

    }

    @Override

    public void setSourceProjection(IProjection projection

    ) {

        this.sourceProjection = projection;

        if (this.parameters instanceof ExportParametersGeometry) {

            ((ExportParametersGeometry) this.parameters).setSourceProjection(projection);

        }

    }

    @Override

    public Object getContext() {

        return context;

    }

    @Override

    public void setContext(Object context

    ) {

        this.context = context;

        if (this.parameters != null) {

            this.parameters.setContext(context);

        }

    }

    @Override

    public ExportParameters getParameters() {

        return this.parameters;

    }

    @Override

    public TaskStatus getTaskStatus() {

        if (this.service == null) {

            throw new IllegalStateException("Can't access task status at this moment, need setting output format.");

        }

        return this.service.getTaskStatus();

    }

    @Override

    public void run() {

        if (this.factory == null) {

            throw new IllegalStateException("Can't start export process, need setting output format.");

        }

        if (this.parameters == null) {

            throw new IllegalStateException("Can't start export process, need setting parameters.");

        }

        try {

            FeatureSet featureSet;

            switch (this.parameters.getFeaturesToUse()) {

                case ExportParameters.USE_ALL_FEATURES:

                default:

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSet();

                    break;

                case ExportParameters.USE_SELECTED_FEATURES:

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSelection();

                    break;

                case ExportParameters.USE_FILTERED_FEATURES:

                    featureSet = this.parameters.getSourceFeatureStore().getFeatureSet(this.parameters.getFilterExpresion());

                    break;

            }

            this.service.export(featureSet);

        } catch (Exception ex) {

            throw new RuntimeException(ex);

        }

    }

    @Override

    public List<OpenDataStoreParameters> getTargetOpenStoreParameters() {

        if (this.service == null) {

            return null;

        }

        try {

            return this.service.getTargetOpenStoreParameters();

        } catch (ExportException ex) {

            throw new RuntimeException("Can't create target open store parameters.", ex);

        }

    }

    @Override

    public void setFilterExpression(Expression expression

    ) {

        this.filterExpression = expression;

        if (this.parameters != null) {

            this.parameters.setFilterExpresion(expression);

        }

        if (expression == null) {

            this.setFeaturesToUse(ExportParameters.USE_ALL_FEATURES);

        } else {

            this.setFeaturesToUse(ExportParameters.USE_FILTERED_FEATURES);

        }

    }

    @Override

    public void setFeaturesToUse(int featuresToUse

    ) {

        this.featuresToUse = featuresToUse;

        if (this.parameters != null) {

            this.parameters.setFeaturesToUse(featuresToUse);

        }

    }

}