Application: gvSIG desktop

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

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 javax.swing.DefaultComboBoxModel;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

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.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 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 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.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.addClearButton(this.txtDefaultValue);

        swingManager.addClearButton(this.txtFieldName);

        swingManager.addClearButton(this.txtIntervalEnd);

        swingManager.addClearButton(this.txtIntervalStart);

        swingManager.addClearButton(this.txtPrecision);

        swingManager.addClearButton(this.txtSize);

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

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

//                this.txtFieldName, DataTypes.STRING

//        );

        this.pickerDefaultValue = evaluatorManager.createCalculatorController(

                this.txtDefaultValue, DataTypes.OBJECT

        );

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

        try {

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

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

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

            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;

            }

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

                Expression expression = this.pickerVirtualField.get();

                if( expression==null ) {

                    descriptor.setFeatureAttributeEmulator(null);

                } else {

                    if( StringUtils.equalsIgnoreCase("Field1", descriptor.getName()) ) {

                        if( !StringUtils.startsWithIgnoreCase(expression.getPhrase(), "IFNULL") ) {

                            LOGGER.info("OOhh!!! sa-roto.");

                        }

                    }

                    DataManager dataManager = DALLocator.getDataManager();

                    FeatureAttributeEmulatorExpression emulator = dataManager.createFeatureAttributeEmulatorExpression(

                            descriptor.getFeatureType(),

                            expression

                    );

                    descriptor.setFeatureAttributeEmulator(emulator);

                }

            }

        } catch (Exception ex) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            dialogs.messageDialog(

                    "Can't retrieve information from user form.", 

                    "Warning", 

                    JOptionPane.WARNING_MESSAGE

            );

        }

        descriptor.setDataProfileName(

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

        );

        return descriptor;

    }

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

    }

    @Override

    public void put(FeatureAttributeDescriptor descriptor) {

        if (descriptor == null) {

            this.clean();

            return;

        }

        ExpressionEvaluatorSwingManager expressionSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        if( descriptor.getFeatureType()!=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());

                }

            }

        }

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

        }

    }

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

        }

    }

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

    }

    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;

        }

    }

    private void doCheckSizeAndPrecision() {

        Integer size = this.pickerSize.get();

        if( size == null ) {

            return;

        }

        int maxsize = this.getMaxSizeOfType((int) ListElement.getSelected(cboFieldType));

        if( size<1 || (maxsize>0 && size>maxsize) ) {

            this.pickerSize.setWarning(true, "The size is not valid for the selected type");

        } else {

            this.pickerSize.setWarning(false);

        }

        if( this.pickerPrecision.isEnabled() ) {

            Integer precision = this.pickerPrecision.get();

            if( precision == null ) {

                return ;

            }

            if( precision < 0 ) {

                this.pickerPrecision.setWarning(true, "the precision can not have a negative value");

            } else if( precision>size ) {

                this.pickerPrecision.setWarning(true, "the precision can not have a value greater than the size");

            } else {

                this.pickerPrecision.setWarning(false);

            }

        }

    }

    @Override

    public void setNameAsNew(FeatureType featureType) {

        this.txtFieldName.setText(DefaultFeatureTypePanel.getNewFieldName(featureType));

    }

    @Override

    public String getName() {

        return StringUtils.defaultIfBlank(this.txtFieldName.getText(), null);

    }

}