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

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JTextField;

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

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

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.StoresRepository;

import org.gvsig.fmap.dal.complements.Search;

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

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

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.feature.ForeingKey;

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.dal.swing.featuretype.FeatureTypePanel;

import static org.gvsig.fmap.dal.swing.featuretype.FeatureTypePanel.MODE_EDIT_ALL;

import static org.gvsig.fmap.dal.swing.featuretype.FeatureTypePanel.MODE_EDIT_ONLY_METADATA;

import static org.gvsig.fmap.dal.swing.featuretype.FeatureTypePanel.MODE_SHOW_ONLY;

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

import org.gvsig.tools.dataTypes.DataType.NumberPrecisionAndScale;

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","Convert2Lambda"})

public class DefaultFeatureTypeAttributePanel

        extends FeatureTypeAttributePanelView

        implements FeatureTypeAttributePanel {

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

    private static class ForeingKeyController {

        private final JCheckBox chkIsForeingKey;

        private final JCheckBox chkIsClosedList;

        private final JComboBox cboTable;

        private final JComboBox cboCode;

        private final JTextField txtFormula;

        private final JButton btnFormula;

        private ExpressionPickerController pickerFormula;

        private boolean editable;

        private FeatureStoreElement featureStoreElement;

        private ForeingKey foreingKey;

        public ForeingKeyController(

                JCheckBox chkIsForeingKey,

                JCheckBox chkIsClosedList,

                JComboBox cboTable,

                JComboBox cboCode,

                JTextField txtFormula,

                JButton btnFormula

        ) {

            this.chkIsForeingKey = chkIsForeingKey;

            this.chkIsClosedList = chkIsClosedList;

            this.cboTable = cboTable;

            this.cboCode = cboCode;

            this.txtFormula = txtFormula;

            this.btnFormula = btnFormula;

            this.initComponents();

        }

        private void initComponents() {

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            this.editable = true;

            DefaultComboBoxModel<String> model = new DefaultComboBoxModel();

            StoresRepository repository = DALLocator.getDataManager().getStoresRepository();

            for (String tableName : repository.keySet()) {

                model.addElement(tableName);

            }

            this.cboTable.setModel(model);

            this.cboTable.addItemListener(new ItemListener() {

                @Override

                public void itemStateChanged(ItemEvent e) {

                    if (e.getStateChange() != ItemEvent.SELECTED) {

                        return;

                    }

                    Thread th = new Thread(new Runnable() {

                        @Override

                        public void run() {

                            doPopulateComboCode();

                        }

                    }, "FeatureTypePanelForeingKeyPopulateComboCode");

                    th.start();

                }

            });

            this.btnFormula.setText("");

            this.featureStoreElement = dataSwingManager.createFeatureStoreElement();

            this.pickerFormula = ExpressionEvaluatorSwingLocator.getManager()

                    .createExpressionPickerController(txtFormula, btnFormula);

            this.pickerFormula.addElement(this.featureStoreElement);

//            this.chkIsForeingKey.addChangeListener(new ChangeListener() {

//                @Override

//                public void stateChanged(ChangeEvent e) {

//                    if (chkIsForeingKey.isSelected()) {

//                        setEnabled(editable);

//                    } else {

//                        setEnabled(false);

//                    }

//                }

//            });

        }

        private void doPopulateComboCode() {

            String tableName = (String) this.cboTable.getSelectedItem();

            if( StringUtils.isBlank(tableName) ) {

                return;

            }

            StoresRepository repository = DALLocator.getDataManager().getStoresRepository();

            DataStore store = repository.getStore(tableName);

            if( !(store instanceof FeatureStore) ) {

                return;

            }

            this.featureStoreElement.setFeatureStore((FeatureStore) store);

            FeatureType featureType;

            try {

                featureType = ((FeatureStore)store).getDefaultFeatureType();

            } catch (DataException ex) {

                return;

            }

            Search search = (Search) ToolsLocator.getComplementsManager().get(

                    Search.COMPLEMENT_MANE, featureType

            );

            List<Search.OrderedAttribute> attributes = search.getOrderedAttributes(

                    Search.BASIC_TYPES_FILTER,

                    Search.LABEL_ORDER, 

                    -1

            );

            final DefaultComboBoxModel model = new DefaultComboBoxModel();

            for (Search.OrderedAttribute attribute : attributes) {

                model.addElement(attribute.getDescriptor().getName());

            }

            SwingUtilities.invokeLater(new Runnable() {

                @Override

                public void run() {

                    cboCode.setModel(model);

                    cboCode.setSelectedItem(foreingKey.getCodeName());

                }

            });

        }

        public void setEditable(boolean editable) {

            this.chkIsForeingKey.setEnabled(editable);

            this.chkIsClosedList.setEnabled(editable);

            this.cboTable.setEnabled(editable);

            this.cboCode.setEnabled(editable);

            this.btnFormula.setEnabled(editable);

            this.txtFormula.setEditable(editable);

            this.editable = editable;

        }

        public void setEnabled(boolean enabled) {

            if( !editable ) {

                enabled =  false;

            }

            this.chkIsForeingKey.setEnabled(enabled);

            this.chkIsClosedList.setEnabled(enabled);

            this.cboTable.setEnabled(enabled);

            this.cboCode.setEnabled(enabled);

            this.btnFormula.setEnabled(enabled);

            this.txtFormula.setEnabled(enabled);

        }

        public void clean() {

            this.chkIsForeingKey.setSelected(false);

            this.chkIsClosedList.setSelected(false);

            this.cboTable.setSelectedItem("");

            this.cboCode.setSelectedItem("");

            this.pickerFormula.set(null);

        }

        public void put(ForeingKey foreingKey) {

            if( foreingKey==null ) {

                this.clean();

                return;

            }

            this.foreingKey = foreingKey;

            this.chkIsForeingKey.setSelected(foreingKey.isForeingKey());

            this.chkIsClosedList.setSelected(foreingKey.isClosedList());

            this.cboTable.setSelectedItem(foreingKey.getTableName());

            this.cboCode.setSelectedItem(foreingKey.getCodeName());

            this.pickerFormula.set(foreingKey.getLabelExpression(null));

        }

        public void fetch(EditableForeingKey foreingKey) {

            if( foreingKey==null ) {

                return;

            }

            foreingKey.setForeingKey(this.chkIsForeingKey.isSelected());

            foreingKey.setClosedList(this.chkIsClosedList.isSelected());

            foreingKey.setTableName((String) this.cboTable.getSelectedItem());

            foreingKey.setCodeName((String) this.cboCode.getSelectedItem());

            Expression exp = this.pickerFormula.get();

            if( ExpressionUtils.isPhraseEmpty(exp) ) {

                foreingKey.setLabelFormula("");

            } else {

                foreingKey.setLabelFormula(exp.getPhrase());

            }

        }

    }

    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<Integer> pickerScale;

    private CalculatorController<Object> pickerDefaultValue;

    private PickerController<IProjection> pickerCRS;

    private ExpressionPickerController pickerVirtualField;

    private CalculatorController<Integer> pickerOrder;

    private AvailableValuesController availableValuesController;

    private TagsController tagsController;

    private ForeingKeyController foreingKeyController;

    private int mode;

    private FeatureStoreElement featureStoreElement;

    public DefaultFeatureTypeAttributePanel() {

        this.mode = FeatureTypePanel.MODE_SHOW_ONLY;

        DataTypesManager dataManager = ToolsLocator.getDataTypesManager();

        this.fieldTypes = new ArrayList<>();

        for (DataType dataType : dataManager) {

            fieldTypes.add( new ListElement<>(dataType.getName(), dataType.getType()) );

        }

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

        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.translate(this.lblTagsName);

        swingManager.translate(this.lblTagsValue);

        swingManager.translate(this.lblForeingKeyCodeName);

        swingManager.translate(this.lblForeingKeyLabelFormula);

        swingManager.translate(this.lblForeingKeyTableName);

        swingManager.translate(this.lblIsClosedList);

        swingManager.translate(this.chkIsForeingKey);

        swingManager.addClearButton(this.txtDefaultValue);

        swingManager.addClearButton(this.txtFieldName);

        swingManager.addClearButton(this.txtIntervalEnd);

        swingManager.addClearButton(this.txtIntervalStart);

        swingManager.addClearButton(this.txtScale);

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

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

        swingManager.setDefaultPopupMenu(this.cboForeingKeyTableName);

        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.foreingKeyController = new ForeingKeyController(

                chkIsForeingKey, 

                chkIsClosedList, 

                cboForeingKeyTableName, 

                cboForeingKeyCodeName, 

                txtForeingKeyFormula, 

                btnForeingKeyFormula

        );

        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.pickerScale = evaluatorManager.createCalculatorController(

                this.txtScale, 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.tagsController = new TagsController(

                tblTags,

                cboTagsName,

                cboTagsValue,

                btnTagsAdd,

                btnTagsUpdate,

                btnTagsRemove,

                lblTagsDescription

        );

        this.txtMinValue.setEnabled(false);

        this.txtMaxValue.setEnabled(false);

        this.btnVirtualField.setText("");

        this.featureStoreElement = dataSwingManager.createFeatureStoreElement();

        this.pickerVirtualField = ExpressionEvaluatorSwingLocator.getManager()

                .createExpressionPickerController(txtVirtualField, btnVirtualField);

        this.pickerVirtualField.addElement(this.featureStoreElement);

        this.chkVirtualField.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                if (chkVirtualField.isSelected()) {

                    pickerVirtualField.setEditable(mode==MODE_EDIT_ALL || mode==MODE_EDIT_ONLY_METADATA);

                } else {

                    pickerVirtualField.setEditable(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) {

                doCheckPrecisionAndScale();

            }

        });

        this.pickerScale.addChangeListener(new ChangeListener() {

            @Override

            public void stateChanged(ChangeEvent e) {

                doCheckPrecisionAndScale();

            }

        });

        DefaultComboBoxModel dataProfilesModel = new DefaultComboBoxModel<>();

        dataProfilesModel.addElement(new ListElement<>("", null));

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

            dataProfilesModel.addElement(new ListElement<>(profile.getName(), profile.getID()));

        }

        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.setScale(this.pickerScale.get(0));

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

            descriptor.setDataProfileName((String) ListElement.getSelected(this.cboDataProfile));

            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) ListElement.getSelected(cboDataProfile), null)

            );

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

                Expression expression = this.pickerVirtualField.get();

                if (expression == null) {

                    descriptor.setFeatureAttributeEmulator((String) 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());

        this.tagsController.fetch(descriptor.getTags());

        this.foreingKeyController.fetch(descriptor.getForeingKey());

        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.pickerScale.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(this.mode==MODE_EDIT_ALL || this.mode==MODE_EDIT_ONLY_METADATA);

        this.pickerVirtualField.setEditable(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();

        this.tagsController.clean();

        this.foreingKeyController.clean();

    }

    @Override

    public void put(FeatureAttributeDescriptor descriptor) {

        if (descriptor == null) {

            this.clean();

            return;

        }

        DataType dataType = descriptor.getDataType();

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

            }

        }

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

        }

        if( dataType.supportSize() ) {

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

        } else {

          this.pickerSize.set(null);

        }

        if( dataType.supportPrecision() ) {

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

        } else {

          this.pickerPrecision.set(null);

        }

        if( dataType.supportScale()) {

          this.pickerScale.set(descriptor.getScale());

        } else {

          this.pickerScale.set(null);

        }

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

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

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

        this.pickerVirtualField.setEnabled(true);

        FeatureAttributeEmulator attrEmulator = descriptor.getFeatureAttributeEmulator();

        if (attrEmulator instanceof FeatureAttributeEmulatorExpression) {

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

            this.chkVirtualField.setEnabled(this.mode==MODE_EDIT_ALL);

            this.chkVirtualField.setSelected(true);

            this.pickerVirtualField.set(expression);

        } else if (descriptor.isComputed()) {

            this.chkVirtualField.setEnabled(false);

            this.chkVirtualField.setSelected(true);

            this.pickerVirtualField.set(null);

        } else {

            this.chkVirtualField.setEnabled(this.mode==MODE_EDIT_ALL);

            this.chkVirtualField.setSelected(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 {

            ListElement.setSelected(this.cboDataProfile, profile);

        }

        this.cboGroup.setModel(groupModel);

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

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

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

        if (descriptor.hasLabel()) {

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

        } else {

            this.txtLabel.setText("");

        }

        if (descriptor.hasDescription()) {

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

        } else {

            this.txtDescription.setText("");

        }

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

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

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

        this.tagsController.set(descriptor.getTags());

        this.foreingKeyController.put(descriptor.getForeingKey());

        if (!(descriptor instanceof EditableFeatureAttributeDescriptor)) {

            this.setMode(FeatureTypePanel.MODE_SHOW_ONLY);

        }

        this.updateEditableStates();

    }

    private DataType getDataType() {

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

      if (fieldType == null) {

          return null;

      }

      DataType dataType = ToolsLocator.getDataTypesManager().get(fieldType);

      return dataType;

    }

    private void doFieldTypeChanged() {

      try {

        DataType dataType = this.getDataType();

        if( dataType.supportSize() ) {

            this.pickerSize.setEditable(this.mode == MODE_EDIT_ALL);

        } else {

            this.pickerSize.setEditable(false);

            this.pickerSize.set(null);

        }        

        if( dataType.supportPrecision() ) {

          if( dataType.isPredefinedPrecision() ) {

            this.pickerPrecision.setEditable(false);

          } else {

            this.pickerPrecision.setEditable(this.mode == MODE_EDIT_ALL);

          }

        } else {

            this.pickerPrecision.setEditable(false);

            this.pickerPrecision.set(null);

        }        

        if( dataType.supportScale()) {

            this.pickerScale.setEditable(this.mode == MODE_EDIT_ALL);

        } else {

            this.pickerScale.setEditable(false);

            this.pickerScale.set(null);

        }        

        switch (dataType.getType()) {

          case DataTypes.GEOMETRY:

            this.cboGeometryType.setEnabled(this.mode == MODE_EDIT_ALL);

            this.cboGeometrySubtype.setEnabled(this.mode == MODE_EDIT_ALL);

            this.pickerCRS.setEditable(this.mode == MODE_EDIT_ALL);

            this.cboDateFormat.setEnabled(false);

            this.pickerIntervalStart.setEditable(false);

            this.pickerIntervalEnd.setEditable(false);

            this.tabAditionalFields.setEnabledAt(1, true);

            this.tabAditionalFields.setEnabledAt(2, 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.setEditable(false);

            this.cboDateFormat.setEnabled(this.mode == MODE_EDIT_ALL || this.mode == MODE_EDIT_ONLY_METADATA);

            this.pickerIntervalStart.setEnabled(this.mode == MODE_EDIT_ALL || this.mode == MODE_EDIT_ONLY_METADATA);

            this.pickerIntervalEnd.setEnabled(this.mode == MODE_EDIT_ALL || this.mode == MODE_EDIT_ONLY_METADATA);

            this.tabAditionalFields.setEnabledAt(1, false);

            this.tabAditionalFields.setEnabledAt(2, true);

            break;

          case DataTypes.BYTE:

          case DataTypes.INT:

          case DataTypes.LONG:

          case DataTypes.STRING:

          case DataTypes.FILE:

          case DataTypes.URL:

          case DataTypes.URI:

          case DataTypes.FLOAT:

          case DataTypes.DOUBLE:

          case DataTypes.DECIMAL:

            this.cboGeometryType.setEnabled(false);

            this.cboGeometrySubtype.setEnabled(false);

            this.pickerCRS.setEditable(false);

            this.cboDateFormat.setEnabled(false);

            this.pickerIntervalStart.setEditable(false);

            this.pickerIntervalEnd.setEditable(false);

            this.tabAditionalFields.setEnabledAt(1, false);

            this.tabAditionalFields.setEnabledAt(2, false);

            break;

          default:

            this.cboGeometryType.setEnabled(false);

            this.cboGeometrySubtype.setEnabled(false);

            this.pickerCRS.setEditable(false);

            this.cboDateFormat.setEnabled(false);

            this.pickerIntervalStart.setEditable(false);

            this.pickerIntervalEnd.setEditable(false);

            this.tabAditionalFields.setEnabledAt(1, false);

            this.tabAditionalFields.setEnabledAt(2, false);

        }

      } catch (Exception ex) {

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

      }

    }

    boolean isVirtualField() {

        return this.chkVirtualField.isSelected();

    }

    @Override

    public int getMode() {

        return this.mode;

    }

    @Override

    public void setMode(int mode) {

        this.mode = mode;

        updateEditableStates();

    }

    private void updateEditableStates() {

        DataType dataType = this.getDataType();

        switch(this.mode) {

            case MODE_EDIT_ALL:

                this.pickerDefaultValue.setEditable(true);

                this.txtFieldName.setEditable(true);

                this.pickerIntervalEnd.setEditable(true);

                this.pickerIntervalStart.setEditable(true);

                this.pickerSize.setEditable(dataType.supportSize());

                if( dataType.isPredefinedPrecision() ) {

                  this.pickerPrecision.setEditable(false);

                  this.pickerPrecision.set(dataType.getMaxPrecision());

                } else {

                  this.pickerPrecision.setEditable(dataType.supportPrecision());

                }

                this.pickerScale.setEditable(dataType.supportScale());

                this.cboDataProfile.setEnabled(true);

                this.chkAllowNulls.setEnabled(true);

                this.chkIsAutomatic.setEnabled(true);

                if( this.isVirtualField() ) {

                    this.chkIsPrimaryKey.setEnabled(false);

                } else {

                    this.chkIsPrimaryKey.setEnabled(true);

                }

                this.chkVirtualField.setEnabled(true);

                this.pickerVirtualField.setEditable(true);

                this.cboDateFormat.setEnabled(true);

                this.cboFieldType.setEnabled(true);

                this.cboGeometryType.setEnabled(true);

                this.cboGeometrySubtype.setEnabled(true);

                this.pickerCRS.setEditable(true);

                this.cboGroup.setEnabled(true);

                this.pickerOrder.setEditable(true);

                this.chkHidden.setEnabled(true);

                this.txtLabel.setEditable(true);

                this.txtDescription.setEditable(true);

                this.txtMinValue.setEditable(false);

                this.txtMaxValue.setEditable(false);

                this.availableValuesController.setEditable(true);

                this.tagsController.setEditable(true);

                this.foreingKeyController.setEditable(true);

                break;

            case MODE_EDIT_ONLY_METADATA:

                if( this.chkVirtualField.isSelected() ) {

                    this.txtFieldName.setEditable(true);

                    this.pickerScale.setEditable(true);

                    this.pickerSize.setEditable(true);

                    this.pickerVirtualField.setEditable(true);

                    this.cboFieldType.setEnabled(true);

                    this.cboGeometryType.setEnabled(true);

                    this.cboGeometrySubtype.setEnabled(true);

                    this.pickerCRS.setEditable(true);

                } else {

                    this.txtFieldName.setEditable(false);

                    this.pickerPrecision.setEditable(false);

                    this.pickerScale.setEditable(false);

                    this.pickerSize.setEditable(false);

                    this.pickerVirtualField.setEditable(false);

                    this.cboFieldType.setEnabled(false);

                    this.cboGeometryType.setEnabled(false);

                    this.cboGeometrySubtype.setEnabled(false);

                    this.pickerCRS.setEditable(false);

                }

                this.pickerDefaultValue.setEditable(true);

                this.pickerIntervalEnd.setEditable(true);

                this.pickerIntervalStart.setEditable(true);

                this.cboDataProfile.setEnabled(true);

                this.chkAllowNulls.setEnabled(false);

                this.chkIsAutomatic.setEnabled(false);

                if( this.isVirtualField() ) {

                    this.chkIsPrimaryKey.setEnabled(false);

                } else {

                    this.chkIsPrimaryKey.setEnabled(true);

                }

                this.chkVirtualField.setEnabled(false);

                this.cboDateFormat.setEnabled(true);

                this.cboGroup.setEnabled(true);

                this.pickerOrder.setEditable(true);

                this.chkHidden.setEnabled(true);

                this.txtLabel.setEditable(true);

                this.txtDescription.setEditable(true);

                this.txtMinValue.setEditable(false);

                this.txtMaxValue.setEditable(false);

                this.availableValuesController.setEditable(true);

                this.tagsController.setEditable(true);

                this.foreingKeyController.setEditable(true);

                break;

            case MODE_SHOW_ONLY:

                this.pickerDefaultValue.setEditable(false);

                this.txtFieldName.setEditable(false);

                this.pickerIntervalEnd.setEditable(false);

                this.pickerIntervalStart.setEditable(false);

                this.pickerPrecision.setEditable(false);

                this.pickerScale.setEditable(false);

                this.pickerSize.setEditable(false);

                this.cboDataProfile.setEnabled(false);

                this.chkAllowNulls.setEnabled(false);

                this.chkIsAutomatic.setEnabled(false);

                this.chkIsPrimaryKey.setEnabled(false);

                this.chkVirtualField.setEnabled(false);

                this.pickerVirtualField.setEditable(false);

                this.cboDateFormat.setEnabled(false);

                this.cboFieldType.setEnabled(false);

                this.cboGeometryType.setEnabled(false);

                this.cboGeometrySubtype.setEnabled(false);

                this.pickerCRS.setEditable(false);

                this.cboGroup.setEnabled(false);

                this.pickerOrder.setEditable(false);

                this.chkHidden.setEnabled(false);

                this.txtLabel.setEditable(false);

                this.txtDescription.setEditable(false);

                this.txtMinValue.setEditable(false);

                this.txtMaxValue.setEditable(false);

                this.availableValuesController.setEditable(false);

                this.tagsController.setEditable(false);

                this.foreingKeyController.setEditable(false);

                break;

        }

    }

    private void doCheckPrecisionAndScale() {

      DataType dataType = this.getDataType();

      Integer precision = this.pickerPrecision.get();

      if( precision==null ) {

        precision = 0;

      }

      Integer scale = this.pickerScale.get();

      if( scale == null ) {

        scale = 0;

      }      

      NumberPrecisionAndScale r = dataType.fixPrecisionAndScale(precision, scale);

      if( r.getPrecision()!=precision || r.getScale()!=scale ) {

        this.pickerPrecision.setWarning(true, "The precision/scale are not valids");

        this.pickerScale.setWarning(true, "The precision/scale are not valids");

      } else {

        this.pickerPrecision.setWarning(false);

        this.pickerScale.setWarning(false);

      }

    }

    @Override

    public void setNameAsNew(FeatureType featureType) {

        EditableFeatureType cloneFeatureType = featureType.getCopy().getEditable();

        EditableFeatureAttributeDescriptor newAttributeDescriptor = cloneFeatureType.add(

                cloneFeatureType.getNewFieldName(), 

                DataTypes.STRING);

        this.put(newAttributeDescriptor);