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.util.Locale;

import javax.swing.JComponent;

import javax.swing.ListCellRenderer;

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.geom.DataTypes;

import org.gvsig.fmap.geom.Geometry;

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

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

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

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.swing.api.ActionListenerSupport;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class JLrsEditRouteCalibrationSelectIdRouteController extends

    JLrsEditRouteCalibrationSelectIdRouteView implements JLrsAlgorithmParams {

    /**

     *

     */

    private static final long serialVersionUID = 7762321351616631999L;

    private static final Logger logger = LoggerFactory

        .getLogger(JLrsEditRouteCalibrationSelectIdRouteController.class);

    private boolean canceled;

    private ActionListenerSupport listeners =

        ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

    private FLayer layer;

    /**

     * @param layer

     * @throws LrsNeededParameterException

     *

     */

    public JLrsEditRouteCalibrationSelectIdRouteController(FLayer layer,

        LrsAlgorithmParams params) throws LrsNeededParameterException {

        super();

        this.layer = layer;

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

        lblIdRouteField

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

        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 an editable curve layer with at least 1 non-geometric

     * field

     * if it is not correct throws an exception

     *

     * @throws LrsNeededParameterException

     * @throws ReadException

     */

    public static void validateLayer(FLayer layer)

        throws LrsNeededParameterException {

        logger.debug("Validating layer for Edit Route");

        if (layer == null) {

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

            throw new LrsNeededParameterException("a_layer_is_needed", null);

        }

        if (!layer.isEditing()) {

            logger.error("An editing layer is needed");

            throw new LrsNeededParameterException("an_editing_layer_is_needed",

                null);

        }

        if (!correctLayerFound(layer)) {

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

            throw new LrsNeededParameterException(

                "impossible_to_find_needed_layer", null);

        }

    }

    /**

     * @throws LrsNeededParameterException

     */

    private void initComponents() throws LrsNeededParameterException {

        validateLayer(layer);

        if (layer instanceof FLyrVect) {

            initCmbIdRouteField((FLyrVect)layer);

        }

        this.btnAccept.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = false;

                doClose();

                listeners.fireActionEvent(new ActionEvent(

                    JLrsEditRouteCalibrationSelectIdRouteController.this, 0,

                    "accept"));

            }

        });

        this.btnCancel.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                canceled = true;

                doClose();

                listeners.fireActionEvent(new ActionEvent(

                    JLrsEditRouteCalibrationSelectIdRouteController.this, 0,

                    "cancel"));

            }

        });

        setVisibleAceptCancel(false);

        canceled = false;

    }

    private void initCmbIdRouteField(FLyrVect layer){

        // Modelos de los combos

        FeatureAttributeDescriptorsComboBoxModel idRouteFieldComboBoxModel =

            new FeatureAttributeDescriptorsComboBoxModel();

        // Renderer para los combos de attributeDescriptors

        ListCellRenderer featureAttributeDescriptorCellRenderer =

            new FLayersAttributeDescriptorCellRenderer();

        // asignaci?n de renderers y modelos

        cmbIdRouteField.setRenderer(featureAttributeDescriptorCellRenderer);

        cmbIdRouteField.setModel(idRouteFieldComboBoxModel);

        FeatureStore featureStore = layer.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.info(new StringBuilder().append("Adding field ")

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

                    cmbIdRouteField.addItem(featureAttributeDescriptor);

                }

            }

        } catch (DataException e1) {

            logger.warn(

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

                    .toString(), e1);

        }

    }

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

        LrsEditRouteCalibrationSelectIdRouteAlgorithmParams params =

            manager.createLrsEditRouteCalibrationSelectIdRouteAlgorithmParams();

            // Recorrer todo del interfaz y rellenar los parametros

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

        return params;

    }

    public void setParams(LrsAlgorithmParams params) {

        if (params == null) {

            clear();

            return;

        }

        // Rellena los campos con los valores de params

        LrsEditRouteCalibrationSelectIdRouteAlgorithmParams parameters =

            (LrsEditRouteCalibrationSelectIdRouteAlgorithmParams) params;

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

    }

    public void clear() {

        this.cmbIdRouteField.setSelectedIndex(0);

    }

    /**

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

     *

     * @param FLayer

     * @return

     * @throws ReadException

     */

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

    }

}