Application: gvSIG desktop » gvSIG Linear Reference System

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2015 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.lrs.swing.impl;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.io.File;

import java.util.Locale;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.JComponent;

import javax.swing.JFileChooser;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.ListCellRenderer;

import javax.swing.filechooser.FileFilter;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.filefilter.FileFilterUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.geom.DataTypes;

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

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

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

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

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

import org.gvsig.fmap.mapcontext.layers.operations.LayerCollection;

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

import org.gvsig.lrs.lib.api.LrsAlgorithmParams;

import org.gvsig.lrs.lib.api.LrsAlgorithmsLocator;

import org.gvsig.lrs.lib.api.LrsAlgorithmsManager;

import org.gvsig.lrs.lib.api.LrsCoordinatesPriority;

import org.gvsig.lrs.lib.api.LrsCreateRouteAlgorithmParams;

import org.gvsig.lrs.lib.api.LrsSourceOfMeasures;

import org.gvsig.lrs.lib.api.exceptions.LrsGettingParametersException;

import org.gvsig.lrs.lib.api.exceptions.LrsNeededParameterException;

import org.gvsig.lrs.swing.api.JLrsAlgorithmParams;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.LocatorException;

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

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

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

/**

 * @author fdiaz

 *

 */

public class JLrsCreateRouteParamsController extends JLrsCreateRouteParamsView implements JLrsAlgorithmParams {

    /**

     *

     */

    private static final long serialVersionUID = 273909136196706713L;

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

    private boolean canceled;

    private ActionListenerSupport listeners = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

    private LayerCollection layers;

    /**

     * @param layers

     *

     */

    public JLrsCreateRouteParamsController(LayerCollection layers, LrsAlgorithmParams params) {

        super();

        this.layers = layers;

        initComponents();

        translate();

        setParams(params);

    }

    public void addActionListener(ActionListener listener) {

        listeners.addActionListener(listener);

    }

    public void removeActionListener(ActionListener listener) {

        listeners.removeActionListener(listener);

    }

    private void translate() {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        lblInputLayer.setText(i18nManager.getTranslation(lblInputLayer.getText()));

        lblIdRouteField.setText(i18nManager.getTranslation(lblIdRouteField.getText()));

        lblOutputFile.setText(i18nManager.getTranslation(lblOutputFile.getText()));

        lblMeasureSource.setText(i18nManager.getTranslation(lblMeasureSource.getText()));

        lblFromMeasureField.setText(i18nManager.getTranslation(lblFromMeasureField.getText()));

        lblToMeasureField.setText(i18nManager.getTranslation(lblToMeasureField.getText()));

        lblCoordinatesPriority.setText(i18nManager.getTranslation(lblCoordinatesPriority.getText()));

        lblMeasureFactor.setText(i18nManager.getTranslation(lblMeasureFactor.getText()));

        lblMeasureOffset.setText(i18nManager.getTranslation(lblMeasureOffset.getText()));

        chkIgnoreSpatialGaps.setText(i18nManager.getTranslation(chkIgnoreSpatialGaps.getText()));

        btnBrowser.setText("\u2026");

        btnAccept.setText(i18nManager.getTranslation(btnAccept.getText()));

        btnCancel.setText(i18nManager.getTranslation(btnCancel.getText()));

    }

    /**

     *

     */

    public void setLocate(Locale locale) {

        Locale l = super.getLocale();

        if (!l.equals(locale)) {

            translate();

        }

        super.setLocale(locale);

    }

    /**

     */

    private void initComponents() {

        // Modelos de los combos

        FLayersComboBoxModel inputLayerModel = new FLayersComboBoxModel(this.layers);

        FeatureAttributeDescriptorsComboBoxModel idRouteFieldComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        FeatureAttributeDescriptorsComboBoxModel fromMeasureFieldComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        FeatureAttributeDescriptorsComboBoxModel toMeasureFieldComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        // Renderer para los combos de attributeDescriptors

        ListCellRenderer featureAttributeDescriptorCellRenderer = new ListCellRenderer() {

            protected DefaultListCellRenderer defaultRenderer = new DefaultListCellRenderer();

            public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,

                boolean cellHasFocus) {

                JLabel renderer =

                    (JLabel) defaultRenderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

                if (value instanceof FeatureAttributeDescriptor) {

                    renderer.setText(((FeatureAttributeDescriptor) value).getName());

                }

                return renderer;

            }

        };

        // asignaci?n de renderers y modelos

        cmbIdRouteField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbFromMeasureField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbToMeasureField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbIdRouteField.setModel(idRouteFieldComboBoxModel);

        cmbFromMeasureField.setModel(fromMeasureFieldComboBoxModel);

        cmbToMeasureField.setModel(toMeasureFieldComboBoxModel);

        // renderer para el combo de capas

        cmbInputLayer.setRenderer(new ListCellRenderer() {

            protected DefaultListCellRenderer defaultRenderer = new DefaultListCellRenderer();

            public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected,

                boolean cellHasFocus) {

                JLabel renderer =

                    (JLabel) defaultRenderer.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

                if (value instanceof FLayer) {

                    renderer.setText(((FLayer) value).getName());

                }

                return renderer;

            }

        });

        // asignaci?n modelo al combo de capas

        cmbInputLayer.setModel(inputLayerModel);

        // listener del combo de capas para que actualice el resto de

        // componentes

        cmbInputLayer.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {

                Object item = e.getItem();

                if (item instanceof FLyrVect) {

                    FLyrVect layer = (FLyrVect) item;

                    updateLayer(layer);

                }

            }

        });

        ComboBoxModel<LrsSourceOfMeasures> measureSourceModel =

            new DefaultComboBoxModel<LrsSourceOfMeasures>(LrsSourceOfMeasures.values());

        cmbMeasureSource.setModel(measureSourceModel);

        cmbMeasureSource.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent event) {

                if (event.getStateChange() == ItemEvent.SELECTED) {

                    LrsSourceOfMeasures item = (LrsSourceOfMeasures) event.getItem();

                    updateSourceOfMeasures(item);

                }

            }

        });

        ComboBoxModel<LrsCoordinatesPriority> coordinatePriorityModel =

            new DefaultComboBoxModel<LrsCoordinatesPriority>(LrsCoordinatesPriority.values());

        cmbCoordinatePriority.setModel(coordinatePriorityModel);

        this.btnBrowser.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                doSelectOuputFile();

            }

        });

        this.btnAccept.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = false;

                doClose();

                listeners.fireActionEvent(new ActionEvent(JLrsCreateRouteParamsController.this, 0, "accept"));

            }

        });

        this.btnCancel.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = true;

                doClose();

                listeners.fireActionEvent(new ActionEvent(JLrsCreateRouteParamsController.this, 0, "cancel"));

            }

        });

        setVisibleAceptCancel(false);

        canceled = false;

    }

    private void doSelectOuputFile() {

        final I18nManager i18nManager = ToolsLocator.getI18nManager();

        ThreadSafeDialogsManager manager = ToolsSwingLocator.getThreadSafeDialogsManager();

        File[] files = manager.showSaveFileDialog(i18nManager.getTranslation("output_file"), null);

        if (files != null && files.length > 0) {

            File file = files[0];

            String absolutePath = file.getAbsolutePath();

            if(!StringUtils.endsWithIgnoreCase(absolutePath, ".shp")){

                absolutePath = new StringBuilder().append(absolutePath).append(".shp").toString();

            }

            File outputFile = FileUtils.getFile(absolutePath);

            if(outputFile.exists()) {

                int resp = JOptionPane.showOptionDialog(

                    this.asJComponent(),

                    i18nManager.getTranslation("file_already_exists_do_you_want_overwrite_it"),

                    i18nManager.getTranslation("output_file"),

                    JOptionPane.OK_CANCEL_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    null,

                    null,

                    JOptionPane.OK_OPTION);

                if (resp == JOptionPane.OK_OPTION){

                    this.txtOutputFile.setText(absolutePath);

                } else {

                    doSelectOuputFile();

                }

            } else {

                this.txtOutputFile.setText(absolutePath);

            }

        }

    }

    private void doClose() {

        this.setVisible(false);

    }

    public boolean isCanceled() {

        return this.canceled;

    }

    public void setVisibleAceptCancel(boolean visible) {

        this.btnAccept.setVisible(visible);

        this.btnCancel.setVisible(visible);

    }

    public boolean getVisibleAceptCancel() {

        return this.btnAccept.isVisible();

    }

    public JComponent asJComponent() {

        return this;

    }

    public LrsAlgorithmParams getParams() throws LrsGettingParametersException, LrsNeededParameterException {

        I18nManager i18nManager = ToolsLocator.getI18nManager();

        FeatureAttributeDescriptor idRouteField = (FeatureAttributeDescriptor) this.cmbIdRouteField.getSelectedItem();

        if (idRouteField == null) {

            throw new LrsNeededParameterException("need_to_select_a_route_identifier_field", null);

        }

        String outputLayerPath = this.txtOutputFile.getText();

        if(StringUtils.isEmpty(outputLayerPath)){

            throw new LrsNeededParameterException("need_to_fill_the_target_path", null);

        }

        LrsAlgorithmsManager manager = LrsAlgorithmsLocator.getLrsAlgorithmsManager();

        LrsCreateRouteAlgorithmParams params = manager.createLrsCreateRouteAlgorithmParams();

        // Recorrer todo del interfaz y rellenar los parametros

        FeatureStore sourceFeatureStore = ((FLyrVect) this.cmbInputLayer.getSelectedItem()).getFeatureStore();

        params.setSourceFeatureStore(sourceFeatureStore);

        params.setIdRouteField((FeatureAttributeDescriptor) this.cmbIdRouteField.getSelectedItem());

        // Crear un SHP a partir de la ruta con el atributo de indentificadores

        // de rutas y pasar el featureStore

        DataManager dataManager = DALLocator.getDataManager();

        FeatureType featureType = dataManager.createFeatureType();

        EditableFeatureType editableFeatureType;

        if (featureType instanceof EditableFeatureType) {

            editableFeatureType = (EditableFeatureType) featureType;

        } else {

            editableFeatureType = featureType.getEditable();

        }

        editableFeatureType.add(idRouteField.getName(), idRouteField.getType(), idRouteField.getSize());

        editableFeatureType.add("GEOMETRY", DataTypes.GEOMETRY);

        editableFeatureType.setDefaultGeometryAttributeName("GEOMETRY");

        EditableFeatureAttributeDescriptor geomAttributeDescriptor =

            editableFeatureType.getEditableAttributeDescriptor("GEOMETRY");

        // FIXME: Cambiar por GEOM2DM;

        try {

            geomAttributeDescriptor.setGeometryType(GeometryLocator.getGeometryManager().getGeometryType(

                TYPES.MULTICURVE, SUBTYPES.GEOM3D));

        } catch (GeometryException e2) {

            throw new LrsGettingParametersException("Error setting geometry type in attribute descriptor", e2);

        } catch (LocatorException e2) {

            throw new LrsGettingParametersException("Error getting geometry manager", e2);

        }

        FeatureType sourceFeatureType;

        try {

            sourceFeatureType = sourceFeatureStore.getDefaultFeatureType();

        } catch (DataException e1) {

            throw new LrsGettingParametersException("Error getting feature type from source feature store", e1);

        }

        IProjection sourceProjection = sourceFeatureType.getDefaultSRS();

        try {

            manager.createNewShape(editableFeatureType, TYPES.MULTICURVE, outputLayerPath, sourceProjection);

        } catch (Exception e1) {

            throw new LrsGettingParametersException(new StringBuilder().append("Error creating a new shape in ")

                .append(outputLayerPath).toString(), e1);

        }

        FeatureStore outputFeatoreStore;

        try {

            outputFeatoreStore = getFeatureStore(outputLayerPath, sourceProjection);

        } catch (Exception e) {

            throw new LrsGettingParametersException(new StringBuilder().append("Error getting feature store from ")

                .append(outputLayerPath).toString(), e);

        }

        params.setOutputFeatoreStore(outputFeatoreStore);

        // FIN DE Crear un SHP a partir de la ruta y de y pasar el featureStore

        LrsSourceOfMeasures measureSources = (LrsSourceOfMeasures) this.cmbMeasureSource.getSelectedItem();

        FeatureAttributeDescriptor fromMeasureField = (FeatureAttributeDescriptor) this.cmbFromMeasureField.getSelectedItem();

        FeatureAttributeDescriptor toMeasureField = (FeatureAttributeDescriptor) this.cmbToMeasureField.getSelectedItem();

        params.setSourceOfMeasures(measureSources);

        switch (measureSources) {

        case ONE_FIELD:

            if (fromMeasureField == null) {

                throw new LrsNeededParameterException("need_to_select_a_from_measure_field", null);

            }

            params.setFromMeasureField((FeatureAttributeDescriptor) this.cmbFromMeasureField.getSelectedItem());

            params.setToMeasureField(null);

            break;

        case TWO_FIELDS:

            if (fromMeasureField == null) {

                throw new LrsNeededParameterException("need_to_select_a_from_measure_field", null);

            }

            params.setFromMeasureField((FeatureAttributeDescriptor) this.cmbFromMeasureField.getSelectedItem());

            if (toMeasureField == null) {

                throw new LrsNeededParameterException("need_to_select_a_to_measure_field", null);

            }

            params.setToMeasureField((FeatureAttributeDescriptor) this.cmbToMeasureField.getSelectedItem());

            break;

        case LENGTH:

        default:

            params.setFromMeasureField(null);

            params.setToMeasureField(null);

            break;

        }

        params.setCoordinatePriority((LrsCoordinatesPriority) this.cmbCoordinatePriority.getSelectedItem());

        Double measureFactor = (Double) this.txtMeasureFactor.getValue();

        params.setMeasureFactor(measureFactor);

        Double measureOffset = (Double) this.txtMeasureOffset.getValue();

        params.setMeasureOffset(measureOffset);

        params.setIgnoreSpatialGaps(this.chkIgnoreSpatialGaps.isSelected());

        return params;

    }

    public void setParams(LrsAlgorithmParams params) {

        if (params == null) {

            clear();

            return;

        }

        // Rellena los campos con los valores de params

        LrsCreateRouteAlgorithmParams parameters = (LrsCreateRouteAlgorithmParams) params;

        this.cmbMeasureSource.setSelectedItem(parameters.getSourceOfMeasures());

        this.cmbCoordinatePriority.setSelectedItem(parameters.getCoordinatePriority());

        FeatureStore outputFeatoreStore = parameters.getOutputFeatoreStore();

        // FIXME: rellenar ?C?mo?

        // this.cmbInputLayer.setSelectedItem(parameters.getSourceFeatureStore());

        // this.txtOutputFile.setText(outputFeatoreStore);

        this.cmbIdRouteField.setSelectedItem(parameters.getIdRouteField());

        this.cmbFromMeasureField.setSelectedItem(parameters.getFromMeasureField());

        this.cmbToMeasureField.setSelectedItem(parameters.getToMeasureField());

        this.txtMeasureFactor.setValue(parameters.getMeasureFactor());

        this.txtMeasureOffset.setValue(parameters.getMeasureOffset());

    }

    public void clear() {

        this.txtOutputFile.setText("");

        this.txtMeasureFactor.setValue(1.0);

        this.txtMeasureOffset.setValue(0.0);

        this.cmbMeasureSource.setSelectedIndex(0);

        this.cmbFromMeasureField.setEnabled(false);

        this.cmbToMeasureField.setEnabled(false);

        this.cmbCoordinatePriority.setSelectedIndex(0);

        Object inputLayerSelected = this.cmbInputLayer.getSelectedItem();

        if (inputLayerSelected != null) {

            this.updateLayer((FLyrVect) inputLayerSelected);

        }

        Object measureSourceSelected = this.cmbMeasureSource.getSelectedItem();

        if (measureSourceSelected != null) {

            this.updateSourceOfMeasures((LrsSourceOfMeasures) measureSourceSelected);

        }

    }

    private void updateLayer(FLyrVect layer) {

        logger.info(new StringBuilder().append("Setting layer ").append(layer.getName()).toString());

        FeatureStore featureStore = layer.getFeatureStore();

        try {

            FeatureType type = featureStore.getDefaultFeatureType();

            // Se renuevan los combos de attributeDescriptors

            FeatureAttributeDescriptorsComboBoxModel idRouteFieldComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            FeatureAttributeDescriptorsComboBoxModel fromMeasureFieldComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            FeatureAttributeDescriptorsComboBoxModel toMeasureFieldComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            this.cmbIdRouteField.setModel(idRouteFieldComboBoxModel);

            this.cmbFromMeasureField.setModel(fromMeasureFieldComboBoxModel);

            this.cmbToMeasureField.setModel(toMeasureFieldComboBoxModel);

            FeatureAttributeDescriptor[] attributeDescriptors = type.getAttributeDescriptors();

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

                FeatureAttributeDescriptor featureAttributeDescriptor = attributeDescriptors[i];

                if (featureAttributeDescriptor.getDataType().getType() != DataTypes.GEOMETRY) {

                    logger.info(new StringBuilder().append("Adding field ")

                        .append(featureAttributeDescriptor.getName()).toString());

                    JLrsCreateRouteParamsController.this.cmbIdRouteField.addItem(featureAttributeDescriptor);

                    if (featureAttributeDescriptor.getDataType().isNumeric()) {

                        JLrsCreateRouteParamsController.this.cmbFromMeasureField.addItem(featureAttributeDescriptor);

                        JLrsCreateRouteParamsController.this.cmbToMeasureField.addItem(featureAttributeDescriptor);

                    }

                }

            }

            this.cmbIdRouteField.invalidate();

            this.cmbFromMeasureField.invalidate();

            this.cmbToMeasureField.invalidate();

        } catch (DataException e1) {

            logger.warn(

                new StringBuilder().append("Error getting default feature type from layer ").append(layer.getName())

                    .toString(), e1);

        }

    }

    private void updateSourceOfMeasures(LrsSourceOfMeasures item) {

        switch (item) {

        case LENGTH:

            cmbFromMeasureField.setEnabled(false);

            cmbToMeasureField.setEnabled(false);

            break;

        case ONE_FIELD:

            cmbFromMeasureField.setEnabled(true);

            cmbToMeasureField.setEnabled(false);

            break;

        case TWO_FIELDS:

            cmbFromMeasureField.setEnabled(true);

            cmbToMeasureField.setEnabled(true);

            break;

        default:

            break;

        }

    }

    protected FeatureStore getFeatureStore(String outputLayerPath, IProjection projection) throws Exception {

        DataManager dataManager = DALLocator.getDataManager();

        DataStoreParameters dataStoreParams = dataManager.createStoreParameters("Shape");

        dataStoreParams.setDynValue("shpfile", outputLayerPath);

        dataStoreParams.setDynValue("CRS", projection);

        dataStoreParams.setDynValue("useNullGeometry", false);

        dataStoreParams.validate();

        return (FeatureStore) dataManager.openStore("Shape", dataStoreParams);

    }

    // private void test() {

    // WindowManager winManager = ToolsSwingLocator.getWindowManager();

    //

    // LrsAlgorithmsSwingManager manager =

    // LrsAlgorithmsSwingLocator.getLrsAlgorithmsSwingManager();

    //

    // JLrsAlgorithmParams panel =

    // manager.createJLrsCreateRouteAlgorithmParameters(null, null);

    // panel.setVisibleAceptCancel(true);

    // winManager.showWindow(panel.asJComponent(), "titulo",

    // WindowManager.MODE.DIALOG);

    // if (panel.isCanceled()) {

    // return;

    // }

    // LrsAlgorithmParams params = panel.getParams();

    // // FIXME: Crear algoritmo con estos parametros

    // }

    //

    // private void test2() {

    // final WindowManager winManager = ToolsSwingLocator.getWindowManager();

    //

    // LrsAlgorithmsSwingManager manager =

    // LrsAlgorithmsSwingLocator.getLrsAlgorithmsSwingManager();

    //

    // JLrsAlgorithmParams panel =

    // manager.createJLrsCreateRouteAlgorithmParameters(null, null);

    // panel.setVisibleAceptCancel(true);

    // panel.addActionListener(new ActionListener() {

    //

    // public void actionPerformed(ActionEvent e) {

    // JLrsAlgorithmParams panel = (JLrsAlgorithmParams) e.getSource();

    // if (panel.isCanceled()) {

    // return;

    // }

    // LrsAlgorithmParams params = panel.getParams();

    // // FIXME: Crear algoritmo con estos parametros

    //

    // LrsAlgorithmsManager algorithmsManager =

    // LrsAlgorithmsLocator.getLrsAlgorithmsManager();

    // final LrsAlgorithm algorithm =

    // algorithmsManager.createLrsAlgorithm(params);

    // final SimpleTaskStatus taskStatus =

    // ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("");

    //

    // // FIXME:

    // DefaultProgressDialogController progressDialog = new

    // DefaultProgressDialogController(taskStatus);

    //

    // // winManager.showWindow(progressDialog.asJComponent(), "TIT",

    // // WindowManager.MODE.WINDOW);

    // winManager.showWindow(progressDialog, "TIT", WindowManager.MODE.WINDOW);

    //

    // Thread task = new Thread(new Runnable() {

    //

    // public void run() {

    // algorithm.execute(taskStatus);

    // }

    // });

    // task.start();

    //

    // }

    // });

    // winManager.showWindow(panel.asJComponent(), "titulo",

    // WindowManager.MODE.WINDOW);

    //

    // }

}