Application: gvSIG desktop

package org.gvsig.fmap.dal.swing.impl.featuretype;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import org.gvsig.fmap.dal.swing.featuretype.FeatureTypeAttributePanel;

import java.awt.event.ItemEvent;

import java.awt.event.ItemListener;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.List;

import java.util.Objects;

import javax.swing.ComboBoxModel;

import javax.swing.DefaultComboBoxModel;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.swing.CalculatorController;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingLocator;

import org.gvsig.expressionevaluator.swing.ExpressionEvaluatorSwingManager;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

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.expressionevaluator.FeatureAttributeEmulatorExpression;

import org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable;

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

import org.gvsig.fmap.dal.swing.expressionevaluator.FeatureStoreElement;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.timesupport.RelativeInterval;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.i18n.I18nManager;

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

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

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

import org.gvsig.tools.swing.api.pickercontroller.DatePickerController;

import org.gvsig.tools.swing.api.pickercontroller.PickerController;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultFeatureTypeAttributePanel

        extends FeatureTypeAttributePanelView

        implements FeatureTypeAttributePanel {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultFeatureTypeAttributePanel.class);

    private static class AvailableValuesController {

        private final JComboBox cboValues;

        private final JTextComponent txtLabel;

        private final JTextComponent txtValue;

        private final JButton btnAdd;

        private final JButton btnUpdate;

        private final JButton btnRemove;

        public AvailableValuesController(

                JComboBox cblValues,

                JTextComponent txtLabel,

                JTextComponent txtValue,

                JButton btnAdd,

                JButton btnUpdate,

                JButton btnRemove

            ) {

            this.cboValues = cblValues;

            this.txtLabel = txtLabel;

            this.txtValue = txtValue;

            this.btnAdd = btnAdd;

            this.btnUpdate = btnUpdate;

            this.btnRemove = btnRemove;

            this.cboValues.addItemListener(new ItemListener() {

                @Override

                public void itemStateChanged(ItemEvent e) {

                    doValuesChanged();

                }

            });

            this.btnAdd.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    doAdd();

                }

            });

            this.btnUpdate.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    doUpdate();

                }

            });

            this.btnRemove.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    doRemove();

                }

            });

        }

        public void clean() {

            this.cboValues.setModel(new DefaultComboBoxModel());

            this.txtLabel.setText("");

            this.txtValue.setText("");

            this.cboValues.setSelectedIndex(-1);

        }

        public DynObjectValueItem[] get() {

            ComboBoxModel<DynObjectValueItem> model = this.cboValues.getModel();

            DynObjectValueItem[] values = new DynObjectValueItem[model.getSize()];

            for (int i = 0; i < model.getSize(); i++) {

                values[i] = model.getElementAt(i);

            }

            return values;

        }

        public void set(DynObjectValueItem[] availableValues) {

            DefaultComboBoxModel model = new DefaultComboBoxModel();

            if( availableValues!=null ) {

                for (DynObjectValueItem availableValue : availableValues) {

                    model.addElement(availableValue);

                }

            }

            this.cboValues.setModel(model);

            if(model.getSize()>0 ) {

                this.cboValues.setSelectedIndex(0);

            } else {

                this.cboValues.setSelectedIndex(-1);

            }

        }

        public void setEditable(boolean editable) {

            this.cboValues.setEnabled(editable);

            this.txtLabel.setEditable(editable);

            this.txtValue.setEditable(editable);

            this.btnAdd.setEnabled(editable);

            this.btnUpdate.setEnabled(editable);

            this.btnRemove.setEnabled(editable);

        }

        private void doValuesChanged() {

            DynObjectValueItem value = (DynObjectValueItem) this.cboValues.getSelectedItem();

            if( value == null ) {

                this.txtLabel.setText("");

                this.txtValue.setText("");

                this.btnAdd.setEnabled(true);

                this.btnUpdate.setEnabled(false);

                this.btnRemove.setEnabled(false);

                return;

            }

            this.txtLabel.setText(value.getLabel());

            this.txtValue.setText(Objects.toString(value.getValue(),""));

            this.btnAdd.setEnabled(true);

            this.btnUpdate.setEnabled(true);

            this.btnRemove.setEnabled(true);

        }

        private void doAdd() {

            DynObjectValueItem value = new DynObjectValueItem("Value", "Label");

            DefaultComboBoxModel model = (DefaultComboBoxModel) this.cboValues.getModel();

            model.addElement(value);

            this.cboValues.setSelectedIndex(model.getSize()-1);

        }

        private void doUpdate() {

            DynObjectValueItem value = (DynObjectValueItem) this.cboValues.getSelectedItem();

            if( value == null ) {

                return; // EEhh?? esto no deberia pasar

            }

            value.setLabel(this.txtLabel.getText());

            value.setValue(this.txtValue.getText());

        }

        private void doRemove() {

            int n = this.cboValues.getSelectedIndex();

            if( n<0 ) {

                return; // EEhh?? esto no deberia pasar

            }

            DefaultComboBoxModel model = (DefaultComboBoxModel) this.cboValues.getModel();

            model.removeElementAt(n);

            if( --n <0 ) {

                n = 0;

            }

            this.cboValues.setSelectedIndex(n);

        }

    }

    private final List<ListElement<Integer>> fieldTypes;

    private final List<ListElement<Integer>> geometryTypes;

    private final List<ListElement<Integer>> geometrySubtypes;

    private DatePickerController pickerIntervalEnd;

    private DatePickerController pickerIntervalStart;

    private CalculatorController<Integer> pickerSize;

    private CalculatorController<Integer> pickerPrecision;

    private CalculatorController<Object> pickerDefaultValue;

    private PickerController<IProjection> pickerCRS;

    private ExpressionPickerController pickerVirtualField;

    private CalculatorController<Integer> pickerOrder;

    private AvailableValuesController availableValuesController;

    private boolean editable;

    private FeatureStoreElement featureStoreElement;

    public DefaultFeatureTypeAttributePanel() {

        this.editable = true;

        DataTypesManager dataManager = ToolsLocator.getDataTypesManager();

        this.fieldTypes = new ArrayList<>();

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.BOOLEAN), DataTypes.BOOLEAN));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.DATE), DataTypes.DATE));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.TIME), DataTypes.TIME));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.TIMESTAMP), DataTypes.TIMESTAMP));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.INT), DataTypes.INT));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.DOUBLE), DataTypes.DOUBLE));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.LONG), DataTypes.LONG));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.INTERVAL), DataTypes.INTERVAL));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.INSTANT), DataTypes.INSTANT));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.STRING), DataTypes.STRING));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.GEOMETRY), DataTypes.GEOMETRY));

        this.fieldTypes.add(new ListElement<>(dataManager.getTypeName(DataTypes.BYTEARRAY), DataTypes.BYTEARRAY));

        this.fieldTypes.sort(new Comparator<ListElement<Integer>>() {

            @Override

            public int compare(ListElement<Integer> o1, ListElement<Integer> o2) {

                return o1.toString().compareTo(o2.toString());

            }

        });

        this.geometryTypes = new ArrayList<>();

        this.geometryTypes.add(new ListElement("Point", Geometry.TYPES.POINT));

        this.geometryTypes.add(new ListElement("Line", Geometry.TYPES.LINE));

        this.geometryTypes.add(new ListElement("Polygon", Geometry.TYPES.POLYGON));

        this.geometryTypes.add(new ListElement("MultiPoint", Geometry.TYPES.MULTIPOINT));

        this.geometryTypes.add(new ListElement("MultiLine", Geometry.TYPES.MULTILINE));

        this.geometryTypes.add(new ListElement("MultiPolygon", Geometry.TYPES.MULTIPOLYGON));

        this.geometryTypes.sort(new Comparator<ListElement<Integer>>() {

            @Override

            public int compare(ListElement<Integer> o1, ListElement<Integer> o2) {

                return o1.toString().compareTo(o2.toString());

            }

        });

        this.geometrySubtypes = new ArrayList<>();

        this.geometrySubtypes.add(new ListElement("2D", Geometry.SUBTYPES.GEOM2D));

        this.geometrySubtypes.add(new ListElement("2DM", Geometry.SUBTYPES.GEOM3D));

        this.geometrySubtypes.add(new ListElement("3D", Geometry.SUBTYPES.GEOM2DM));

        this.geometrySubtypes.add(new ListElement("3DM", Geometry.SUBTYPES.GEOM3DM));

        this.geometrySubtypes.sort(new Comparator<ListElement<Integer>>() {

            @Override

            public int compare(ListElement<Integer> o1, ListElement<Integer> o2) {

                return o1.toString().compareTo(o2.toString());

            }

        });

        this.initComponents();

    }

    private void initComponents() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        ExpressionEvaluatorSwingManager evaluatorManager = ExpressionEvaluatorSwingLocator.getManager();

        DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        DefaultComboBoxModel<ListElement<Integer>> modelTypes = new DefaultComboBoxModel<>();

        for (ListElement<Integer> element : fieldTypes) {

            modelTypes.addElement(element);

        }

        this.cboFieldType.setModel(modelTypes);

        DefaultComboBoxModel<ListElement<Integer>> modelGeomTypes = new DefaultComboBoxModel<>();

        for (ListElement<Integer> element : this.geometryTypes) {

            modelGeomTypes.addElement(element);

        }

        this.cboGeometryType.setModel(modelGeomTypes);

        DefaultComboBoxModel<ListElement<Integer>> modelGeomSubtypes = new DefaultComboBoxModel<>();

        for (ListElement<Integer> element : this.geometrySubtypes) {

            modelGeomSubtypes.addElement(element);

        }

        this.cboGeometrySubtype.setModel(modelGeomSubtypes);

        swingManager.translate(this.lblAllowNulls);

        swingManager.translate(this.lblCRS);

        swingManager.translate(this.lblDataProfile);

        swingManager.translate(this.lblDateFormat);

        swingManager.translate(this.lblDefaultValue);

        swingManager.translate(this.lblFieldName);

        swingManager.translate(this.lblFieldType);

        swingManager.translate(this.lblGeometrySubtype);

        swingManager.translate(this.lblGeometryType);

        swingManager.translate(this.lblInterval);

        swingManager.translate(this.lblIntervalEnd);

        swingManager.translate(this.lblIntervalStart);

        swingManager.translate(this.lblIsAutomatic);

        swingManager.translate(this.lblIsPrimaryKey);

        swingManager.translate(this.lblPrecision);

        swingManager.translate(this.lblSize);

        swingManager.translate(this.chkVirtualField);

        swingManager.translate(this.tabAditionalFields);

        swingManager.translate(this.tabLayout);

        swingManager.translate(this.lblGroup);

        swingManager.translate(this.lblOrder);

        swingManager.translate(this.lblHidden);

        swingManager.translate(this.lblLabel);

        swingManager.translate(this.lblDescription);

        swingManager.translate(this.lblMinValue);

        swingManager.translate(this.lblMaxValue);

        swingManager.translate(this.lblAvailableValues);

        swingManager.translate(this.lblAvailableValuesLabel);

        swingManager.translate(this.lblAvailableValuesValue);

        swingManager.translate(this.btnAvailableValuesAdd);

        swingManager.translate(this.btnAvailableValuesUpdate);

        swingManager.translate(this.btnAvailableValuesRemove);

        swingManager.addClearButton(this.txtDefaultValue);

        swingManager.addClearButton(this.txtFieldName);

        swingManager.addClearButton(this.txtIntervalEnd);

        swingManager.addClearButton(this.txtIntervalStart);

        swingManager.addClearButton(this.txtPrecision);

        swingManager.addClearButton(this.txtSize);

        swingManager.addClearButton(this.txtLabel);

        swingManager.addClearButton(this.txtDescription);

        swingManager.addClearButton(this.cboGroup);

        swingManager.addClearButton(this.txtMaxValue);

        swingManager.addClearButton(this.txtMinValue);

        swingManager.addClearButton(this.txtAvailableValuesLabel);

        swingManager.addClearButton(this.txtAvailableValuesValue);

        swingManager.setDefaultPopupMenu(this.txtDefaultValue);

        swingManager.setDefaultPopupMenu(this.txtFieldName);

        swingManager.setDefaultPopupMenu(this.txtIntervalEnd);

        swingManager.setDefaultPopupMenu(this.txtIntervalStart);

        swingManager.setDefaultPopupMenu(this.txtPrecision);

        swingManager.setDefaultPopupMenu(this.txtSize);

        swingManager.setDefaultPopupMenu(this.cboDateFormat);

        swingManager.setDefaultPopupMenu(this.cboFieldType);

        swingManager.setDefaultPopupMenu(this.cboGeometrySubtype);

        swingManager.setDefaultPopupMenu(this.cboGeometryType);

        swingManager.setDefaultPopupMenu(this.cboDataProfile);

        swingManager.setDefaultPopupMenu(this.cboGroup);

        swingManager.setDefaultPopupMenu(this.txtOrder);

        swingManager.setDefaultPopupMenu(this.txtLabel);

        swingManager.setDefaultPopupMenu(this.txtDescription);

        swingManager.setDefaultPopupMenu(this.txtMinValue);

        swingManager.setDefaultPopupMenu(this.txtMaxValue);

        swingManager.setDefaultPopupMenu(this.txtAvailableValuesLabel);

        swingManager.setDefaultPopupMenu(this.txtAvailableValuesValue);

        this.pickerIntervalEnd = swingManager.createDatePickerController(

                this.txtIntervalEnd,

                this.btnIntervalEnd

        );

        this.pickerIntervalStart = swingManager.createDatePickerController(

                this.txtIntervalStart,

                this.btnIntervalStart

        );

        this.pickerSize = evaluatorManager.createCalculatorController(

                this.txtSize, DataTypes.INT

        );

        this.pickerPrecision = evaluatorManager.createCalculatorController(

                this.txtPrecision, DataTypes.INT

        );

        this.pickerDefaultValue = evaluatorManager.createCalculatorController(

                this.txtDefaultValue, DataTypes.OBJECT

        );

        this.pickerOrder = evaluatorManager.createCalculatorController(

                this.txtOrder, DataTypes.INT

        );

        this.availableValuesController = new AvailableValuesController(

                cboAvailableValues,

                txtAvailableValuesLabel,

                txtAvailableValuesValue,

                btnAvailableValuesAdd,

                btnAvailableValuesUpdate,

                btnAvailableValuesRemove

        );

        this.txtMinValue.setEnabled(false);

        this.txtMaxValue.setEnabled(false);

        this.btnVirtualField.setText("");

        this.pickerVirtualField = ExpressionEvaluatorSwingLocator.getManager()

                .createExpressionPickerController(txtVirtualField, btnVirtualField);

        this.featureStoreElement = dataSwingManager.createFeatureStoreElement(

                this.pickerVirtualField

        );

        this.pickerVirtualField.addElement(this.featureStoreElement);

        this.chkVirtualField.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                if (chkVirtualField.isSelected()) {

                    pickerVirtualField.setEnabled(editable);

                } else {

                    pickerVirtualField.setEnabled(false);

                }

            }

        });

        this.pickerCRS = dataSwingManager.createProjectionPickerController(

                this.txtCRS, this.btnCRS

        );

        this.cboFieldType.addItemListener(new ItemListener() {

            @Override

            public void itemStateChanged(ItemEvent e) {

                SwingUtilities.invokeLater(new Runnable() {

                    @Override

                    public void run() {

                        doFieldTypeChanged();

                    }

                });

            }

        });

        this.pickerPrecision.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                doCheckSizeAndPrecision();

            }

        });

        this.pickerSize.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                doCheckSizeAndPrecision();

            }

        });

        DefaultComboBoxModel<String> dataProfilesModel = new DefaultComboBoxModel<>();

        dataProfilesModel.addElement(" ");

        for (DataProfile profile : DALLocator.getDataManager().getDataProfiles()) {

            dataProfilesModel.addElement(profile.getName());

        }

        this.cboDataProfile.setModel(dataProfilesModel);

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public EditableFeatureAttributeDescriptor fetch(EditableFeatureAttributeDescriptor descriptor) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        try {

            if( !this.chkAllowNulls.isSelected() ) {

                if( descriptor.allowNull() ) {

                    ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                    dialogs.messageDialog(

                            i18n.getTranslation("_You_have_marked_not_allow_nulls")+ "\n" +

                            i18n.getTranslation("If_you_are_not_fully_aware_of_the_repercussions_of_this_it_is_advisable_to_allow_nulls"),

                            null,

                            i18n.getTranslation("_Warning"),

                            JOptionPane.INFORMATION_MESSAGE,

                            "AllowNullsInFeatureTypeEditing"

                    );

                }

            }

            descriptor.setDataType((int) ListElement.getSelected(this.cboFieldType));

            descriptor.setName(this.txtFieldName.getText());

            descriptor.setAllowNull(this.chkAllowNulls.isSelected());

            descriptor.setIsPrimaryKey(this.chkIsPrimaryKey.isSelected());

            descriptor.setIsAutomatic(this.chkIsAutomatic.isSelected());

            descriptor.setSize(this.pickerSize.get(0));

            descriptor.setPrecision(this.pickerPrecision.get(0));

            descriptor.setDefaultValue(this.pickerDefaultValue.get());

            descriptor.setDataProfileName((String) this.cboDataProfile.getSelectedItem());

            switch (descriptor.getType()) {

                case DataTypes.GEOMETRY:

                    GeometryManager geomManager = GeometryLocator.getGeometryManager();

                    GeometryType geomType = geomManager.getGeometryType(

                            (int) ListElement.getSelected(this.cboGeometryType),

                            (int) ListElement.getSelected(this.cboGeometrySubtype)

                    );

                    descriptor.setGeometryType(geomType);

                    descriptor.setSRS(this.pickerCRS.get());

                    break;

                case DataTypes.INSTANT:

                case DataTypes.INTERVAL:

                case DataTypes.DATE:

                case DataTypes.TIME:

                case DataTypes.TIMESTAMP:

                    // FIXME

                    break;

                default:

                    break;

            }

            descriptor.setDataProfileName(

                StringUtils.defaultIfBlank((String) this.cboDataProfile.getSelectedItem(),null)

            );

            if( this.chkVirtualField.isSelected() && this.pickerVirtualField.isEnabled() ) {

                Expression expression = this.pickerVirtualField.get();

                if( expression==null ) {

                    descriptor.setFeatureAttributeEmulator(null);

                } else {

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureAttributeEmulatorExpression emulator = dataManager.createFeatureAttributeEmulatorExpression(

                            descriptor.getFeatureType(),

                            expression

                    );

                    if( !emulator.isValid() ) {

                        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                        dialogs.messageDialog(

                                i18n.getTranslation("_The_expression_of_virtual_field_is_not_valid")+

                                    "\n"+

                                    emulator.getErrorMessage(),

                                i18n.getTranslation("_Warning"),

                                JOptionPane.WARNING_MESSAGE

                        );

                        return null;

                    }

                    for (String requiredFieldName : emulator.getRequiredFieldNames()) {

                        if( StringUtils.equalsIgnoreCase(requiredFieldName, descriptor.getName()) ) {

                            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

                            dialogs.messageDialog(

                                    i18n.getTranslation("_The_expression_of_virtual_field_is_not_valid")+

                                        "\n\n"+

                                        i18n.getTranslation("_The_expression_contains_a_reference_to_itself"),

                                    i18n.getTranslation("_Warning"),

                                    JOptionPane.WARNING_MESSAGE

                            );

                            return null;

                        }

                    }

                    descriptor.setFeatureAttributeEmulator(emulator);

                    //

                    // No se porque esto de abajo no funciona.

                    // Nunca se lanza la excepcion en el get(Feature) de

                    // DefaultFeatureAttributeEmulatorExpression.

                    //

//                    try {

//                        emulator.setEnableExceptions(true);

//                        descriptor.setFeatureAttributeEmulator(emulator);

//                        this.pickerVirtualField.getPreviewSymbolTable().value(descriptor.getName());

//                    } catch(Throwable ex) {

//                        emulator.setEnableExceptions(false);

//                        descriptor.setFeatureAttributeEmulator(null);

//                        ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

//                        dialogs.messageDialog(

//                                i18n.getTranslation("_The_expression_of_virtual_field_is_not_valid")+

//                                    "\n"+

//                                    ex.getMessage(),

//                                i18n.getTranslation("_Warning"),

//                                JOptionPane.WARNING_MESSAGE

//                        );

//                        return null;

//                    } finally {

//                        emulator.setEnableExceptions(false);

//                    }

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't retrieve information from user form.",ex);

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    i18n.getTranslation("_Cant_retrieve_information_from_user_form")+

                        "\n"+

                        i18n.getTranslation("_See_log_for_details"),

                    i18n.getTranslation("_Warning"),

                    JOptionPane.WARNING_MESSAGE

            );

            return null;

        }

        descriptor.setGroup(StringUtils.defaultIfBlank((String) this.cboGroup.getSelectedItem(), null));

        descriptor.setOrder(this.pickerOrder.get(0));

        descriptor.setHidden(this.chkHidden.isSelected());

        descriptor.setLabel(StringUtils.defaultIfBlank(this.txtLabel.getText(), null));

        descriptor.setDescription(StringUtils.defaultIfBlank(this.txtDescription.getText(), null));

//        this.txtMinValue.setText(Objects.toString(descriptor.getMinValue(), ""));

//        this.txtMinValue.setText(Objects.toString(descriptor.getMaxValue(), ""));

        descriptor.setAvailableValues(this.availableValuesController.get());

        return descriptor;

    }

    @Override

    public void clean() {

        this.pickerDefaultValue.set(null);

        this.txtFieldName.setText("");

//        this.pickerFieldName.set(null);

        this.pickerIntervalEnd.set(null);

        this.pickerIntervalStart.set(null);

        this.pickerPrecision.set(null);

        this.pickerSize.set(null);

        this.chkAllowNulls.setSelected(false);

        this.chkIsAutomatic.setSelected(false);

        this.chkIsPrimaryKey.setSelected(false);

        this.chkVirtualField.setSelected(false);

        this.chkVirtualField.setEnabled(editable);

        this.pickerVirtualField.setEnabled(false);

        this.pickerVirtualField.set(null);

        ListElement.setSelected(cboGeometryType, null);

        ListElement.setSelected(cboGeometrySubtype, null);

        ListElement.setSelected(cboFieldType, DataTypes.STRING);

        this.cboDataProfile.setSelectedIndex(-1);

        this.cboGroup.setSelectedIndex(-1);

        this.pickerOrder.set(null);

        this.chkHidden.setSelected(false);

        this.txtLabel.setText("");

        this.txtDescription.setText("");

        this.txtMinValue.setText("");

        this.txtMaxValue.setText("");

        this.availableValuesController.clean();

    }

    @Override

    public void put(FeatureAttributeDescriptor descriptor) {

        if (descriptor == null) {

            this.clean();

            return;

        }

        FeatureType featureType = descriptor.getFeatureType();

        DefaultComboBoxModel groupModel = new DefaultComboBoxModel();

        if( featureType!=null ) {

            FeatureStore store = descriptor.getFeatureType().getStore();

            this.featureStoreElement.setFeatureStore(store);

            if( store != null ) {

                Feature sampleFeature = null;

                try {

                    sampleFeature = store.getFeatureSelection().first();

                    if( sampleFeature == null ) {

                        sampleFeature = store.first();

                    }

                } catch (DataException ex) {

                }

                if( sampleFeature!=null ) {

                    FeatureSymbolTable featureSymbolTable = DALLocator.getDataManager().createFeatureSymbolTable();

                    featureSymbolTable.setFeature(sampleFeature);

                    this.pickerVirtualField.setPreviewSymbolTable(featureSymbolTable.createParent());

                }

            }

            List<String> groups = new ArrayList<>();

            for (FeatureAttributeDescriptor otherdesc : featureType) {

                String group = otherdesc.getGroup();

                if( !StringUtils.isBlank(group) && !groups.contains(group) ) {

                    groups.add(group);

                }

            }

            for (String group : groups) {

                groupModel.addElement(group);

            }

        }

        if (!(descriptor instanceof EditableFeatureAttributeDescriptor)) {

            this.setEditable(false);

        }

        this.pickerDefaultValue.set(descriptor.getDefaultValue());

        this.txtFieldName.setText(descriptor.getName());

        RelativeInterval interval = (RelativeInterval) descriptor.getInterval();

        if (interval == null) {

            this.pickerIntervalEnd.set(null);

            this.pickerIntervalStart.set(null);

        } else {

            this.pickerIntervalEnd.set(interval.getEnd().toDate());

            this.pickerIntervalStart.set(interval.getStart().toDate());

        }

        this.pickerPrecision.set(descriptor.getPrecision());

        this.pickerSize.set(descriptor.getSize());

        this.chkAllowNulls.setSelected(descriptor.allowNull());

        this.chkIsAutomatic.setSelected(descriptor.isAutomatic());

        this.chkIsPrimaryKey.setSelected(descriptor.isPrimaryKey());

        FeatureAttributeEmulator attrEmulator = descriptor.getFeatureAttributeEmulator();

        if (attrEmulator instanceof FeatureAttributeEmulatorExpression) {

            Expression expression = ((FeatureAttributeEmulatorExpression) attrEmulator).getExpression();

            this.chkVirtualField.setEnabled(editable);

            this.chkVirtualField.setSelected(true);

            this.pickerVirtualField.setEnabled(editable);

            this.pickerVirtualField.set(expression);

        } else if (descriptor.isComputed()) {

            this.chkVirtualField.setEnabled(false);

            this.chkVirtualField.setSelected(true);

            this.pickerVirtualField.setEnabled(false);

            this.pickerVirtualField.set(null);

        } else {

            this.chkVirtualField.setEnabled(editable);

            this.chkVirtualField.setSelected(false);

            this.pickerVirtualField.setEnabled(false);

            this.pickerVirtualField.set(null);

        }

        this.pickerCRS.set(descriptor.getSRS());

        if (descriptor.getGeomType() != null) {

            ListElement.setSelected(cboGeometryType, descriptor.getGeomType().getType());

            ListElement.setSelected(cboGeometrySubtype, descriptor.getGeomType().getSubType());

        }

        ListElement.setSelected(cboFieldType, descriptor.getType());

        String profile = descriptor.getDataProfileName();

        if( StringUtils.isBlank(profile) ) {

            this.cboDataProfile.setSelectedIndex(-1);

        } else {

           this.cboDataProfile.setSelectedItem(profile);

        }

        this.cboGroup.setModel(groupModel);

        this.cboGroup.setSelectedItem(StringUtils.defaultIfBlank(descriptor.getGroup(),""));

        this.pickerOrder.set(descriptor.getOder());

        this.chkHidden.setSelected(descriptor.isHidden());

        this.txtLabel.setText(StringUtils.defaultIfBlank(descriptor.getLabel(),""));

        this.txtDescription.setText(StringUtils.defaultIfBlank(descriptor.getDescription(),""));

        this.txtMinValue.setText(Objects.toString(descriptor.getMinValue(), ""));

        this.txtMinValue.setText(Objects.toString(descriptor.getMaxValue(), ""));

        this.availableValuesController.set(descriptor.getAvailableValues());

    }

    private void doFieldTypeChanged() {

        try {

            Integer fieldType = (Integer) ListElement.getSelected(this.cboFieldType);

            if (fieldType == null) {

                fieldType = DataTypes.UNKNOWN;

            }

            Integer size = this.pickerSize.get();

            if( fieldType == DataTypes.STRING ) {

                if( size == null ) {

                    this.pickerSize.set(50);

                }

            } else {

                int maxsize = this.getMaxSizeOfType(fieldType);

                if( size==null || (maxsize>0 && size>maxsize) ) {

                    this.pickerSize.set(maxsize);

                }

            }

            Integer precision = this.pickerPrecision.get();

            if( precision==null ) {

                int defaultPrecision = this.getDefaultPrecisionOfType(fieldType);

                if( defaultPrecision>0 ) {

                    this.pickerPrecision.set(defaultPrecision);

                }

            }

            switch (fieldType) {

                case DataTypes.GEOMETRY:

                    this.cboGeometryType.setEnabled(editable);

                    this.cboGeometrySubtype.setEnabled(editable);

                    this.pickerCRS.setEnabled(editable);

                    this.cboDateFormat.setEnabled(false);

                    this.pickerIntervalStart.setEnabled(false);

                    this.pickerIntervalEnd.setEditable(false);

                    this.tabAditionalFields.setEnabledAt(1, true);

                    this.tabAditionalFields.setEnabledAt(2, false);

                    this.pickerSize.set(null);

                    this.pickerPrecision.set(null);

                    this.pickerSize.setEnabled(false);

                    this.pickerPrecision.setEnabled(false);

                    break;

                case DataTypes.INSTANT:

                case DataTypes.INTERVAL:

                case DataTypes.DATE:

                case DataTypes.TIME:

                case DataTypes.TIMESTAMP:

                    this.cboGeometryType.setEnabled(false);

                    this.cboGeometrySubtype.setEnabled(false);

                    this.pickerCRS.setEnabled(false);

                    this.cboDateFormat.setEnabled(editable);

                    this.pickerIntervalStart.setEnabled(editable);

                    this.pickerIntervalEnd.setEnabled(editable);

                    this.tabAditionalFields.setEnabledAt(1, false);

                    this.tabAditionalFields.setEnabledAt(2, true);

                    this.pickerSize.set(null);

                    this.pickerPrecision.set(null);

                    this.pickerSize.setEnabled(false);

                    this.pickerPrecision.setEnabled(false);

                    break;

                case DataTypes.BYTE:

                case DataTypes.INT:

                case DataTypes.LONG:

                case DataTypes.STRING:

                    this.cboGeometryType.setEnabled(false);

                    this.cboGeometrySubtype.setEnabled(false);

                    this.pickerCRS.setEnabled(false);

                    this.cboDateFormat.setEnabled(false);

                    this.pickerIntervalStart.setEnabled(false);

                    this.pickerIntervalEnd.setEditable(false);

                    this.tabAditionalFields.setEnabledAt(1, false);

                    this.tabAditionalFields.setEnabledAt(2, false);

                    this.pickerPrecision.set(null);

                    this.pickerSize.setEnabled(true);

                    this.pickerPrecision.setEnabled(false);

                    break;

                case DataTypes.FLOAT:

                case DataTypes.DOUBLE:

                    this.cboGeometryType.setEnabled(false);

                    this.cboGeometrySubtype.setEnabled(false);

                    this.pickerCRS.setEnabled(false);

                    this.cboDateFormat.setEnabled(false);

                    this.pickerIntervalStart.setEnabled(false);

                    this.pickerIntervalEnd.setEditable(false);

                    this.tabAditionalFields.setEnabledAt(1, false);

                    this.tabAditionalFields.setEnabledAt(2, false);

                    this.pickerSize.setEnabled(true);

                    this.pickerPrecision.setEnabled(true);

                    break;

                default:

                    this.cboGeometryType.setEnabled(false);

                    this.cboGeometrySubtype.setEnabled(false);

                    this.pickerCRS.setEnabled(false);

                    this.cboDateFormat.setEnabled(false);

                    this.pickerIntervalStart.setEnabled(false);

                    this.pickerIntervalEnd.setEditable(false);

                    this.tabAditionalFields.setEnabledAt(1, false);

                    this.tabAditionalFields.setEnabledAt(2, false);

                    this.pickerSize.set(null);

                    this.pickerPrecision.set(null);

                    this.pickerSize.setEnabled(false);

                    this.pickerPrecision.setEnabled(false);

            }

        } catch (Exception ex) {

            LOGGER.warn("Problems changing field type.",ex);

        }

    }

    @Override

    public void setEditable(boolean editable) {

        this.editable = editable;

        this.pickerDefaultValue.setEditable(editable);

        this.txtFieldName.setEditable(editable);

//        this.pickerFieldName.setEditable(editable);

        this.pickerIntervalEnd.setEditable(editable);

        this.pickerIntervalStart.setEditable(editable);

        this.pickerPrecision.setEditable(editable);

        this.pickerSize.setEditable(editable);

        this.cboDataProfile.setEnabled(editable);

        this.chkAllowNulls.setEnabled(editable);

        this.chkIsAutomatic.setEnabled(editable);

        this.chkIsPrimaryKey.setEnabled(editable);

        this.chkVirtualField.setEnabled(editable);

        this.pickerVirtualField.setEditable(editable);

        this.cboDateFormat.setEnabled(editable);

        this.cboFieldType.setEnabled(editable);

        this.cboGeometryType.setEnabled(editable);

        this.cboGeometrySubtype.setEnabled(editable);

        this.pickerCRS.setEditable(editable);

        this.cboGroup.setEnabled(editable);

        this.pickerOrder.setEditable(editable);

        this.chkHidden.setEnabled(editable);

        this.txtLabel.setEditable(editable);

        this.txtDescription.setEditable(editable);

        this.txtMinValue.setEditable(false);

        this.txtMaxValue.setEditable(false);

        this.availableValuesController.setEditable(editable);

    }

    private int getMaxSizeOfType(int dataType) {

        switch(dataType) {

            case DataTypes.BOOLEAN:

                return 1;

            case DataTypes.BYTE:

                return 3;

            case DataTypes.INT:

                return 9;

            case DataTypes.LONG:

                return 19;

            case DataTypes.FLOAT:

                return 20;

            case DataTypes.DOUBLE:

                return 20;

            case DataTypes.DATE:

                return 8;

            default:

                return -1;

        }

    }

    private int getDefaultPrecisionOfType(int dataType) {

        switch(dataType) {

            case DataTypes.FLOAT:

                return 6;

            case DataTypes.DOUBLE:

                return 6;

            default:

                return -1;

        }

    }