Application: gvSIG desktop » gvSIG Linear Reference System

/*

 * Copyright 2015 DiSiD Technologies S.L.L. All rights reserved.

 *

 * Project  : DiSiD org.gvsig.lrs.swing.impl

 * SVN Id   : $Id$

 */

package org.gvsig.lrs.swing.impl;

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

import java.util.Locale;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.ListCellRenderer;

import org.apache.commons.io.FileUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableBoolean;

import org.cresques.cts.IProjection;

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.exception.ReadException;

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.dal.feature.NewFeatureStoreParameters;

import org.gvsig.fmap.dal.store.shp.SHPNewStoreParameters;

import org.gvsig.fmap.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

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

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

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.exception.BaseException;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class JLrsGenerateDynamicSegmentationParamsController extends

    JLrsGenerateDynamicSegmentationParamsView implements JLrsAlgorithmParams {

    private static final Logger logger = LoggerFactory

        .getLogger(JLrsGenerateDynamicSegmentationParamsController.class);

    private boolean canceled;

    private ActionListenerSupport listeners =

        ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

    private LayerCollection layers;

    private List<FeatureStore> tables;

    /**

     * @param layers

     * @throws LrsNeededParameterException

     *

     */

    public JLrsGenerateDynamicSegmentationParamsController(

        LayerCollection layers, List<FeatureStore> tables,

        LrsAlgorithmParams params) throws LrsNeededParameterException {

        super();

        this.layers = layers;

        this.tables = tables;

        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()));

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

        lblTableIdRouteField.setText(

            i18nManager.getTranslation(lblTableIdRouteField.getText()));

        lblLandmarkField

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

        lblFinalLandmarkField.setText(

            i18nManager.getTranslation(lblFinalLandmarkField.getText()));

        lblValueField

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

        lblOutputFile

            .setText(i18nManager.getTranslation(lblOutputFile.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);

    }

    /**

     * Validates it is a curve layer with at least 1 non-geometric

     * field

     * if it is not correct throws an exception

     *

     * @throws LrsNeededParameterException

     * @throws ReadException

     */

    public static void validateLayers(LayerCollection layers)

        throws LrsNeededParameterException {

        logger.debug("Validating layer for Generate Dynamic Segmentation");

        if (layers == null || layers.getLayersCount() < 1) {

            logger.error("A layer is needed");

            throw new LrsNeededParameterException("a_layer_is_needed", null);

        }

        if (!correctLayerFound(layers)) {

            logger.error("Impossible to find the layer needed");

            throw new LrsNeededParameterException(

                "impossible_to_find_needed_layer", null);

        }

    }

    /**

     * Validates if there is a valid table:

     * - at least two fields

     * - one of them is numeric

     * if can't find any throws an exception

     *

     * @throws LrsNeededParameterException

     * @throws ReadException

     */

    public static void validateTables(List<FeatureStore> tables)

        throws LrsNeededParameterException {

        logger.debug("Validating tables for Generate Dynamic Segmentation");

        if (tables == null || tables.size() < 1) {

            logger.error("A table is needed");

            throw new LrsNeededParameterException("a_table_is_needed", null);

        }

        if (!correctTableFound(tables)) {

            logger.error("Impossible to find the layer needed");

            throw new LrsNeededParameterException(

                "impossible_to_find_needed_layer", null);

        }

    }

    /**

     * @throws LrsNeededParameterException

     */

    private void initComponents() throws LrsNeededParameterException {

        validateLayers(layers);

        validateTables(tables);

        // Modelos de los combos

        FLayersComboBoxModel inputLayerModel =

            new FLayersComboBoxModel(this.layers);

        FeatureAttributeDescriptorsComboBoxModel idRouteFieldComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        FeatureStoresComboBoxModel tableLayerModel =

            new FeatureStoresComboBoxModel(this.tables);

        FeatureAttributeDescriptorsComboBoxModel tableIdRouteFieldComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        FeatureAttributeDescriptorsComboBoxModel landmarkComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        FeatureAttributeDescriptorsComboBoxModel finalLandmarkComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        FeatureAttributeDescriptorsComboBoxModel valueComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        // Renderer para los combos de attributeDescriptors

        ListCellRenderer featureAttributeDescriptorCellRenderer =

            new FLayersAttributeDescriptorCellRenderer();

        // asignaci?n de renderers y modelos

        cmbIdRouteField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbTableIdRouteField

            .setRenderer(featureAttributeDescriptorCellRenderer);

        cmbLandmarkField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbFinalLandmarkField

            .setRenderer(featureAttributeDescriptorCellRenderer);

        cmbValueField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbIdRouteField.setModel(idRouteFieldComboBoxModel);

        cmbTableIdRouteField.setModel(tableIdRouteFieldComboBoxModel);

        cmbLandmarkField.setModel(landmarkComboBoxModel);

        cmbFinalLandmarkField.setModel(finalLandmarkComboBoxModel);

        cmbValueField.setModel(valueComboBoxModel);

        // renderer para el combo de capas

        ListCellRenderer layerNameCellRenderer =

            new FLayersLayerNameCellRenderer();

        ListCellRenderer featureStorerNameCellRenderer =

            new FeatureStoreNameCellRenderer();

        cmbInputLayer.setRenderer(layerNameCellRenderer);

        cmbTable.setRenderer(featureStorerNameCellRenderer);

        // asignaci?n modelo al combo de capas

        cmbInputLayer.setModel(inputLayerModel);

        cmbTable.setModel(tableLayerModel);

        // 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;

                    updateLayerSource(layer);

                }

            }

        });

        cmbTable.addItemListener(new ItemListener() {

            public void itemStateChanged(ItemEvent e) {

                Object item = e.getItem();

                if (item instanceof FeatureStore) {

                    FeatureStore featureStore = (FeatureStore) item;

                    updateTable(featureStore);

                }

            }

        });

        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(

                    JLrsGenerateDynamicSegmentationParamsController.this, 0,

                    "accept"));

            }

        });

        this.btnCancel.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = true;

                doClose();

                listeners.fireActionEvent(new ActionEvent(

                    JLrsGenerateDynamicSegmentationParamsController.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 {

        LrsAlgorithmsManager manager = LrsAlgorithmsLocator.getLrsAlgorithmsManager();

        LrsGenerateDynamicSegmentationAlgorithmParams params =manager.createLrsGenerateDynamicSegmentationAlgorithmParams();

        // Recorrer todo del interfaz y rellenar los parametros

        //cmbInputLayer

        if (!(this.cmbInputLayer.getSelectedItem() instanceof FLyrVect)){

            logger.error("Error getting selected item from cmbInputLayer");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbInputLayer", null);

        }

        FLyrVect fLyrVect = (FLyrVect) this.cmbIdRouteField.getSelectedItem();

        if (!(fLyrVect.getFeatureStore() instanceof FeatureStore)){

            logger.error("Error getting selected item from cmbInputLayer");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbInputLayer", null);

        }

        FeatureStore sourceFeatureStore = (FeatureStore)fLyrVect.getFeatureStore();

        if (sourceFeatureStore == null) {

            throw new LrsNeededParameterException("need_to_select_a_source_layer", null);

        }

        params.setSourceFeatureStore(sourceFeatureStore);

        //cmbIdRouteField

        if (!(this.cmbIdRouteField.getSelectedItem() instanceof FeatureAttributeDescriptor)){

            logger.error("Error getting selected item from cmbIdRouteField");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbIdRouteField", null);

        }

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

        if (idRouteField == null) {

            throw new LrsNeededParameterException("need_to_select_a_route_identifier_field", null);

        }

        params.setIdRouteField(idRouteField);

        //cmbTable

        if (!(this.cmbTable.getSelectedItem() instanceof FeatureStore)){

            logger.error("Error getting selected item from cmbTable");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbTable", null);

        }

        FeatureStore tableFeatureStore = (FeatureStore) this.cmbTable.getSelectedItem();

        if (tableFeatureStore == null) {

            throw new LrsNeededParameterException("need_to_select_a_table", null);

        }

        params.setValueTableFeatureStore(tableFeatureStore);

        //cmbTableIdRouteField

        if (!(this.cmbTableIdRouteField.getSelectedItem() instanceof FeatureAttributeDescriptor)){

            logger.error("Error getting selected item from cmbTableIdRouteField");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbTableIdRouteField", null);

        }

        FeatureAttributeDescriptor tableIdRouteField = (FeatureAttributeDescriptor) this.cmbTableIdRouteField.getSelectedItem();

        params.setValueTableIdRouteField(tableIdRouteField);

        //cmbLandmarkField

        if (!(this.cmbLandmarkField.getSelectedItem() instanceof FeatureAttributeDescriptor)){

            logger.error("Error getting selected item from cmbLandmarkField");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbLandmarkField", null);

        }

        FeatureAttributeDescriptor landmarkField = (FeatureAttributeDescriptor) this.cmbLandmarkField.getSelectedItem();

        if (landmarkField == null) {

            throw new LrsNeededParameterException("need_to_select_a_landmark_field", null);

        }

        params.setLandmarkField(landmarkField);

        //cmbFinalLandmarkField

        if (!(this.cmbFinalLandmarkField.getSelectedItem() instanceof FeatureAttributeDescriptor)){

            logger.error("Error getting selected item from cmbFinalLandmarkField");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbFinalLandmarkField", null);

        }

        FeatureAttributeDescriptor finalLandmarkField = (FeatureAttributeDescriptor) this.cmbFinalLandmarkField.getSelectedItem();

        params.setFinalLandmarkField(finalLandmarkField);

        //cmbValue

        if (!(this.cmbValueField.getSelectedItem() instanceof FeatureAttributeDescriptor)){

            logger.error("Error getting selected item from cmbValueField");

            throw new LrsGettingParametersException("error_getting_selected_item_from_cmbValueField", null);

        }

        FeatureAttributeDescriptor valueField = (FeatureAttributeDescriptor) this.cmbValueField.getSelectedItem();

        if (valueField == null) {

            throw new LrsNeededParameterException("need_to_select_a_value_field", null);

        }

        params.setValueField(valueField);

        //OutputStore

        String outputLayerPath = this.txtOutputFile.getText();

        if(StringUtils.isEmpty(outputLayerPath)){

            throw new LrsNeededParameterException("need_to_fill_the_target_path", null);

        }

        SHPNewStoreParameters sHPNewStoreParameters=new SHPNewStoreParameters();

        sHPNewStoreParameters.setFile(outputLayerPath);

        params.setNewFeatureStoreParameters((NewFeatureStoreParameters)sHPNewStoreParameters);

        return params;

    }

    public void setParams(LrsAlgorithmParams params) {

        if (params == null) {

            clear();

            return;

        }

        // Rellena los campos con los valores de params

        LrsGenerateDynamicSegmentationAlgorithmParams parameters = (LrsGenerateDynamicSegmentationAlgorithmParams) params;

        FeatureStore sourceFeatureStore = parameters.getSourceFeatureStore();

        if(layers!=null && sourceFeatureStore!=null){

            FLayer layer = layers.getLayer(sourceFeatureStore.getName());

            this.cmbInputLayer.setSelectedItem(layer);

        }

        FeatureStore tableFeaturesStore=parameters.getValueTableFeatureStore();

        if(tables!=null && tableFeaturesStore!=null){

            this.cmbTable.setSelectedItem(tableFeaturesStore.getName());

        }

        NewFeatureStoreParameters newFeatureStoreParameters = parameters.getNewFeatureStoreParameters();

        if(newFeatureStoreParameters!=null && newFeatureStoreParameters instanceof SHPNewStoreParameters){

            this.txtOutputFile.setText(((SHPNewStoreParameters)newFeatureStoreParameters).getSHPFile().getAbsolutePath());

        }

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

        this.cmbTableIdRouteField.setSelectedItem(parameters.getValueTableIdRouteField());

        this.cmbLandmarkField.setSelectedItem(parameters.getLandmarkField());

        this.cmbFinalLandmarkField.setSelectedItem(parameters.getFinalLandmarkField());

        this.cmbValueField.setSelectedItem(parameters.getValueField());

    }

    public void clear() {

        this.txtOutputFile.setText("");

        this.cmbInputLayer.setSelectedIndex(0);

        Object inputLayerSelected = this.cmbInputLayer.getSelectedItem();

        if (inputLayerSelected != null) {

            this.updateLayerSource((FLyrVect) inputLayerSelected);

        }

        this.cmbTable.setSelectedIndex(0);

        Object tableSelected = this.cmbTable.getSelectedItem();

        if (tableSelected != null) {

            this.updateTable((FeatureStore) tableSelected);

        }

        this.cmbIdRouteField.setSelectedIndex(0);

        this.cmbTableIdRouteField.setSelectedIndex(0);

        this.cmbLandmarkField.setSelectedIndex(0);

        this.cmbFinalLandmarkField.setSelectedIndex(0);

        this.cmbValueField.setSelectedIndex(0);

    }

    private void updateLayerSource(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();

            this.cmbIdRouteField.setModel(idRouteFieldComboBoxModel);

            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());

                    JLrsGenerateDynamicSegmentationParamsController.this.cmbIdRouteField

                        .addItem(featureAttributeDescriptor);

                }

            }

            this.cmbIdRouteField.invalidate();

        } catch (DataException e1) {

            logger.warn(new StringBuilder()

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

                .append(layer.getName()).toString(), e1);

        }

    }

    private void updateTable(FeatureStore featureStore) {

        logger.info(new StringBuilder().append("Setting featureStore ")

            .append(featureStore.getName()).toString());

        try {

            FeatureType type = featureStore.getDefaultFeatureType();

            // Se renuevan los combos de attributeDescriptors

            FeatureAttributeDescriptorsComboBoxModel tableIdRouteComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            FeatureAttributeDescriptorsComboBoxModel landmarkComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            FeatureAttributeDescriptorsComboBoxModel finalLandmarkComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            FeatureAttributeDescriptorsComboBoxModel valueComboBoxModel =

                new FeatureAttributeDescriptorsComboBoxModel();

            this.cmbTableIdRouteField.setModel(tableIdRouteComboBoxModel);

            this.cmbLandmarkField.setModel(landmarkComboBoxModel);

            this.cmbFinalLandmarkField.setModel(finalLandmarkComboBoxModel);

            this.cmbValueField.setModel(valueComboBoxModel);

            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());

                    JLrsGenerateDynamicSegmentationParamsController.this.cmbTableIdRouteField

                        .addItem(featureAttributeDescriptor);

                    JLrsGenerateDynamicSegmentationParamsController.this.cmbValueField

                    .addItem(featureAttributeDescriptor);

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

                        JLrsGenerateDynamicSegmentationParamsController.this.cmbLandmarkField

                            .addItem(featureAttributeDescriptor);

                        JLrsGenerateDynamicSegmentationParamsController.this.cmbFinalLandmarkField

                        .addItem(featureAttributeDescriptor);

                    }

                }

            }

            this.cmbTableIdRouteField.invalidate();

            this.cmbLandmarkField.invalidate();

            this.cmbFinalLandmarkField.invalidate();

            this.cmbValueField.invalidate();

        } catch (DataException e1) {

            logger

                .warn(new StringBuilder()

                    .append(

                        "Error getting default feature type from featureStore ")

                    .append(featureStore.getName()).toString(), e1);

        }

    }

    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);

    }

    /**

     * Tries to find a curve M-layer with at least one non-geometrical field

     *

     * @param layers

     * @return

     */

    private static boolean correctLayerFound(LayerCollection layers) {

        final MutableBoolean correctLayerFound=new MutableBoolean(false);

        if (layers != null) {

            try {

                layers.accept(new Visitor() {

                    public void visit(Object obj)

                        throws VisitCanceledException, BaseException {

                        FLayer layer = (FLayer) obj;

                        if (JLrsGenerateDynamicSegmentationParamsController

                            .correctLayerFound(layer)) {

                            correctLayerFound.setValue(true);

                            throw new VisitCanceledException();

                        }

                    }

                });

            } catch (VisitCanceledException e) {

                //VisitCanceledException is not working properly

                //so, we have to use final MutableBoolean correctLayerFound

                return true;

            }

            catch (BaseException e) {

                logger.warn("Error visiting layer");

            }

        }

        return correctLayerFound.getValue();

    }

    /**

     * Verifies if it is a curve M-layer with at least one non-geometrical field

     *

     * @param FLayer

     * @return

     * @throws ReadException

     */

    public static boolean correctLayerFound(FLayer layer) {

        boolean correctLayerFound = false;

        // Validates is FLyrVect

        FLyrVect lyrVect = null;

        if (layer instanceof FLyrVect) {

            lyrVect = (FLyrVect) layer;

        } else

            return false;

        try {

            if (lyrVect != null

                && (lyrVect.getGeometryType().isTypeOf(Geometry.TYPES.CURVE)

                    || lyrVect.getGeometryType()

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

                // TODO M-geometry commented to test button

                // if (lyrVect.getGeometryType()

                // .isSubTypeOf(Geometry.SUBTYPES.GEOM2DM) ||

                // lyrVect.getGeometryType()

                // .isSubTypeOf(Geometry.SUBTYPES.GEOM3DM)) {

                FeatureStore featureStore = lyrVect.getFeatureStore();

                try {

                    FeatureType type = featureStore.getDefaultFeatureType();

                    FeatureAttributeDescriptor[] attributeDescriptors =

                        type.getAttributeDescriptors();

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

                        FeatureAttributeDescriptor featureAttributeDescriptor =

                            attributeDescriptors[i];

                        if (featureAttributeDescriptor.getDataType()

                            .getType() != DataTypes.GEOMETRY) {

                            logger.debug("Correct curve layer found");

                            return true;

                        }

                    }

                    // type.getDefaultGeometryAttribute().getGeomType().isSubTypeOf(Geometry.SUBTYPES.GEOM2DM)

                } catch (DataException e1) {

                    logger.warn(new StringBuilder()

                        .append(

                            "Error getting default feature type from layer ")

                        .append(lyrVect.getName()).toString(), e1);

                }

                // }

            }

        } catch (Exception e) {

            logger.error("Can't get linear vector layers", e);

        }

        return correctLayerFound;

    }

    /**

     * Validates if there is a valid table:

     * - at least two fields

     * - one of them is numeric

     * if can't find any throws an exception

     *

     * @throws LrsNeededParameterException

     * @throws ReadException

     */

    public static boolean correctTableFound(List<FeatureStore> tables) {

        for (FeatureStore featureStore : tables) {

            try {

                FeatureType type = featureStore.getDefaultFeatureType();

                FeatureAttributeDescriptor[] attributeDescriptors =

                    type.getAttributeDescriptors();

                if (attributeDescriptors.length >= 2) {

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

                        FeatureAttributeDescriptor featureAttributeDescriptor =

                            attributeDescriptors[i];

                        if (featureAttributeDescriptor.getDataType()

                            .isNumeric()) {

                            logger.debug("Correct table found");

                            return true;

                        }

                    }

                }

            } catch (DataException e1) {

                logger.warn("Error getting default feature type");

            }

        }

        return false;

    }

}