Application: gvSIG desktop

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

import java.awt.Component;

import java.awt.event.ActionEvent;

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

import java.awt.event.ItemEvent;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Locale;

import java.util.Objects;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.DefaultListModel;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JScrollPane;

import javax.swing.JSplitPane;

import javax.swing.JTextField;

import javax.swing.ListModel;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ListSelectionEvent;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Callable;

import org.gvsig.expressionevaluator.Code.Constant;

import org.gvsig.expressionevaluator.Code.Identifier;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.Expression;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_GETATTR;

import static org.gvsig.expressionevaluator.ExpressionBuilder.OPERATOR_EQ;

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 static org.gvsig.fmap.dal.DataManager.FUNCTION_SELECT;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.StoresRepository;

import static org.gvsig.fmap.dal.complements.RelatedFeatures.DAL_RELATED_TABLE;

import static org.gvsig.fmap.dal.complements.RelatedFeatures.DAL_RELATED_UNIQUE_FIELD_NAME;

import org.gvsig.fmap.dal.exception.DataException;

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

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

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

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

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 static org.gvsig.fmap.dal.swing.impl.DefaultDALSwingLibrary.LIBRARY_NAME;

import org.gvsig.fmap.dal.swing.impl.featuretype.tags.Tag;

import org.gvsig.fmap.dal.swing.impl.featuretype.tags.TagController;

import org.gvsig.fmap.dal.swing.impl.featuretype.tags.TagsModel;

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

import org.gvsig.tools.dynobject.DynObjectValueItem;

import org.gvsig.tools.dynobject.Tags;

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

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.gvsig.tools.swing.api.windowmanager.Dialog;

import org.gvsig.tools.swing.api.windowmanager.WindowManager;

import org.gvsig.tools.swing.api.windowmanager.WindowManager_v2;

import org.gvsig.tools.swing.icontheme.IconTheme;

import org.gvsig.tools.util.LabeledValue;

import org.gvsig.tools.util.LabeledValueImpl;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings({"UseSpecificCatch"})

public class DefaultFeatureAttributePanel

        extends DefaultFeatureAttributePanelView

        implements FeatureTypeAttributePanel {

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

    // ----

    // Los he eliminado del GUI pero los mantengo aqui por si decido rescatarlos

    private final JTextComponent txtMaxValue = new JTextField();

    private final JTextComponent txtMinValue = new JTextField();

    private final JComponent lblMinValue = new JLabel();

    private final JComponent lblMaxValue = new JLabel();

    // ----

    private Feature sampleFeature;

    private String previousDefaultValue;

    private ToManyController toManyController;

    private JSplitPane splAttrTags;

    private static class ToOneController {

        private final JTextComponent txtMyFieldName;

        private final JComboBox cboRelationType;

        private final JCheckBox chkIsClosedList;

        private final JComboBox cboTable;

        private final JComboBox cboForeignField;

        private final JComboBox cboFormula;

        private final JButton btnFormula;

        private final JButton btnFormulaHistory;

        private final JButton btnFormulaBokkmarks;

        private AttributeDescriptorAndExpressionPickerController pickerFormula;

        private AttributeDescriptorPickerController pickerCode;

        private boolean editable;

        private ForeingKey foreingKey;

        public ToOneController(

                JTextComponent txtMyFieldName,

                JComboBox cboRelationType,

                JCheckBox chkIsClosedList,

                JComboBox cboTable,

                JComboBox cboCode,

                JComboBox cboFormula,

                JButton btnFormula,

                JButton btnFormulaBokkmarks,

                JButton btnFormulaHistory

        ) {

            this.txtMyFieldName = txtMyFieldName;

            this.cboRelationType = cboRelationType;

            this.chkIsClosedList = chkIsClosedList;

            this.cboTable = cboTable;

            this.cboForeignField = cboCode;

            this.cboFormula = cboFormula;

            this.btnFormula = btnFormula;

            this.btnFormulaHistory = btnFormulaHistory;

            this.btnFormulaBokkmarks = btnFormulaBokkmarks;

            this.initComponents();

        }

        private void initComponents() {

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.editable = true;

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

//            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_None"),DynField.RELATION_TYPE_NONE));

            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Identity_1_1"),DynField.RELATION_TYPE_IDENTITY));

            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Collaboration_1_1_without_composition"),DynField.RELATION_TYPE_COLLABORATION));

            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Collaboration_1_1_with_composition"),DynField.RELATION_TYPE_COLLABORATION_WITH_COMPOSITION));

//            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Aggregate_1_N_without_composition"),DynField.RELATION_TYPE_AGGREGATE_WITH_COMPOSITION));

//            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Aggregate_1_N_with_composition"),DynField.RELATION_TYPE_AGGREGATE));

            this.cboRelationType.setModel(relationTypeModel);

            DefaultComboBoxModel<String> model = new DefaultComboBoxModel();

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

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

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

                tableNames.add(tableName);

            }

            Collections.sort(tableNames);

            for (String tableName : tableNames) {

                model.addElement(tableName);

            }

            this.cboTable.setEditable(false);

            this.cboTable.setModel(model);

            this.cboTable.addItemListener((ItemEvent e) -> {

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

                return;

              }

              Thread th = new Thread(() -> {

                doTableChanged();

              }, "FeatureTypePanelToOneChangeTable");

              th.start();

            });

            this.pickerCode = dataSwingManager.createAttributeDescriptorPickerController(cboForeignField);

            this.btnFormula.setText("");

            this.btnFormulaBokkmarks.setText("");

            this.btnFormulaHistory.setText("");

            this.pickerFormula = dataSwingManager.createExpressionPickerController(

                    null, 

                    cboFormula, 

                    btnFormula, 

                    btnFormulaBokkmarks, 

                    btnFormulaHistory

            );

            this.pickerFormula.setAllowNull(true);

        }

        private void doTableChanged() {

            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;

            }

            FeatureType featureType;

            try {

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

            } catch (DataException ex) {

                return;

            }

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            this.pickerCode.setAllowNull(true);

            this.pickerCode.setFeatureType(featureType);

            if (featureType == null) {

                return;

            }

            dataSwingManager.configureExpressionBuilder(this.pickerFormula.getConfig(), ((FeatureStore)store));

            SwingUtilities.invokeLater(() -> {

              cboForeignField.setSelectedItem(foreingKey.getCodeName());

            });

        }

        public void setEditable(boolean editable) {

            this.cboRelationType.setEnabled(editable);

            this.chkIsClosedList.setEnabled(editable);

            this.cboTable.setEnabled(editable);

            this.cboForeignField.setEnabled(editable);

            this.pickerFormula.setEditable(editable);

            this.editable = editable;

        }

        public void setEnabled(boolean enabled) {

            if( !editable ) {

                enabled =  false;

            }

            this.cboRelationType.setEnabled(enabled);

            this.chkIsClosedList.setEnabled(enabled);

            this.cboTable.setEnabled(enabled);

            this.cboForeignField.setEnabled(enabled);

            this.pickerFormula.setEditable(enabled);

        }

        public void clean() {

            this.txtMyFieldName.setText("");

            this.cboRelationType.setSelectedIndex(-1);

            this.chkIsClosedList.setSelected(false);

            this.cboTable.setSelectedItem("");

            this.cboForeignField.setSelectedItem("");

            this.pickerFormula.set(null);

        }

        public void put(FeatureAttributeDescriptor descriptor) {

            if( descriptor == null ) {

                this.clean();

                return;

            }

            ForeingKey foreingKey = descriptor.getForeingKey();

            if( foreingKey==null ) {

                this.clean();

                return;

            }

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

            this.pickerFormula.setFeatureType(repository.getFeatureType(foreingKey.getTableName()));

            this.foreingKey = foreingKey;

            ListElement.setSelected(this.cboRelationType,descriptor.getRelationType());

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

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

            doTableChanged();

            this.pickerCode.set(foreingKey.getCodeName());

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

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

        }

        public void fetch(EditableFeatureAttributeDescriptor descriptor) {

            if( descriptor == null ) {

                this.clean();

                return;

            }

            EditableForeingKey foreingKey = descriptor.getForeingKey();

            if( foreingKey==null ) {

                return;

            }

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

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

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

            foreingKey.setCodeName(this.pickerCode.getName());

            Expression exp = this.pickerFormula.get();

            if( ExpressionUtils.isPhraseEmpty(exp) ) {

                foreingKey.setLabelFormula("");

            } else {

                foreingKey.setLabelFormula(exp.getPhrase());

            }

        }

        public int getRelationType() {

            Object n = this.cboRelationType.getSelectedItem();

            if( n == null ) {

                return DynField.RELATION_TYPE_NONE;

            }

            return ((LabeledValue<Integer>)n).getValue();

        }

    }

    private static class ToManyController {

        private final JComboBox cboRelationType;

        private final JComboBox cboMyField;

        private final JComboBox cboTable;

        private final JComboBox cboForeignField;

        private final JTextField txtExpression;

        private final JButton btnExpression;

        private final JButton btnExpressionHistory;

        private final JButton btnExpressionBokkmarks;

        private ExpressionPickerController pickerExpression;

        private AttributeDescriptorPickerController pickerForeignField;

        private AttributeDescriptorPickerController pickerMyField;

        private boolean editable;

        private boolean disableEvents;

        public ToManyController(

                JComboBox cboRelationType,

                JComboBox cboMyField,

                JComboBox cboTable,

                JComboBox cboForeignField,

                JTextField txtExpression,

                JButton btnExpression,

                JButton btnExpressionBokkmarks,

                JButton btnExpressionHistory

        ) {

            this.disableEvents = false;

            this.cboRelationType = cboRelationType;

            this.cboMyField = cboMyField;

            this.cboTable = cboTable;

            this.cboForeignField = cboForeignField;

            this.txtExpression = txtExpression;

            this.btnExpression = btnExpression;

            this.btnExpressionHistory = btnExpressionHistory;

            this.btnExpressionBokkmarks = btnExpressionBokkmarks;

            this.initComponents();

        }

        private void initComponents() {

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.editable = true;

            DefaultComboBoxModel<LabeledValueImpl<Integer>> relationTypeModel = new DefaultComboBoxModel<>();

//            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Identity_1_1"),DynField.RELATION_TYPE_IDENTITY));

//            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Collaboration_1_1_without_composition"),DynField.RELATION_TYPE_COLLABORATION));

//            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Collaboration_1_1_with_composition"),DynField.RELATION_TYPE_COLLABORATION_WITH_COMPOSITION));

            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Aggregate_1_N_with_composition"),DynField.RELATION_TYPE_AGGREGATE_WITH_COMPOSITION));

            relationTypeModel.addElement(new ListElement<>(i18n.getTranslation("_Aggregate_1_N_without_composition"),DynField.RELATION_TYPE_AGGREGATE));

            this.cboRelationType.setModel(relationTypeModel);

            this.pickerMyField = dataSwingManager.createAttributeDescriptorPickerController(cboMyField);

            this.pickerMyField.setAllowNull(true);

            this.pickerMyField.addChangeListener((ChangeEvent e) -> {

                if( disableEvents ) {

                    return;

                }

                doUpdateExpression();

            });

            DefaultComboBoxModel<String> model = new DefaultComboBoxModel();

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

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

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

                tableNames.add(tableName);

            }

            Collections.sort(tableNames);

            for (String tableName : tableNames) {

                model.addElement(tableName);

            }

            this.cboTable.setEditable(false);

            this.cboTable.setModel(model);

            this.cboTable.addItemListener((ItemEvent e) -> {

              if( disableEvents ) {

                  return;

              }

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

                return;

              }

              Thread th = new Thread(() ->

                  { doTableChanged(); },

                "FeatureTypePanelToManyTableChanged"

              );

              th.start();

            });

            this.pickerForeignField = dataSwingManager.createAttributeDescriptorPickerController(cboForeignField);

            this.pickerForeignField.setAllowNull(true);

            this.pickerForeignField.addChangeListener((ChangeEvent e) -> {

                if( disableEvents ) {

                    return;

                }

                doUpdateExpression();

            });

            this.pickerExpression = ExpressionEvaluatorSwingLocator.getManager().createExpressionPickerController(

                    txtExpression, 

                    btnExpression, 

                    btnExpressionBokkmarks, 

                    btnExpressionHistory

            );

        }

        private void doTableChanged() {

            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;

            }

            FeatureStore featureStore = (FeatureStore) store;

            FeatureType featureType;

            try {

                featureType = featureStore.getDefaultFeatureType();

            } catch (DataException ex) {

                return;

            }

            DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

            this.pickerForeignField.setFeatureType(featureType);

            if (featureType == null) {

                return;

            }

            dataSwingManager.configureExpressionBuilder(this.pickerExpression.getConfig(), featureStore);

        }

        private void doUpdateExpression() {

            String myField = this.pickerMyField.getName();

            if( StringUtils.isBlank(myField) ) {

                this.pickerExpression.set(null);

                return;

            }

            String foreignField = this.pickerForeignField.getName();

            if( StringUtils.isBlank(foreignField) ) {

                this.pickerExpression.set(null);

                return;

            }

            String tableName = this.getTableName();

            if( StringUtils.isBlank(tableName) ) {

                this.pickerExpression.set(null);

                return;

            }

            DataManager dataManager = DALLocator.getDataManager();

            DALExpressionBuilder builder = dataManager.createDALExpressionBuilder();

            SQLBuilder.SelectBuilder select = builder.select();

            select.from().table().name(tableName);

            select.column().all();

            select.where().set(builder.expression().eq(

                    builder.expression().column(myField),

                    builder.expression().getattr(tableName, foreignField)

                )

            );

            this.pickerExpression.set(ExpressionUtils.createExpression(select.toString()));

        }

        private String[] getFieldsAndTable(Expression expression) {

            if (ExpressionUtils.isEmpty(expression)) {

                return null;

            }

            try {

                Code code = expression.getCode();

                if( !StringUtils.equalsIgnoreCase(Callable.name(code),FUNCTION_SELECT) ) {

                    return null;

                }

                Code.Callable callable = (Code.Callable) code;

                String tableName;

                Codes args = callable.parameters();

                Code storeName_code = (Code) args.get(1);

                if (storeName_code instanceof Code.Identifier) {

                    tableName = ((Code.Identifier) storeName_code).name();

                } else if (storeName_code instanceof Code.Constant) {

                    Code.Constant storeName_const = (Code.Constant) storeName_code;

                    if (storeName_const.value() instanceof CharSequence) {

                        tableName = storeName_const.value().toString();

                    } else {

                        return null;

                    }

                } else {

                    return null;

                }

                if (StringUtils.isBlank(tableName)) {

                    return null;

                }

                String foreignColumnName = null;

                String myColumnName = null;

                Code where = callable.parameters().get(2); // WHERE

                Code myFieldCode = getCode(

                        where,

                        new ImmutablePair<>(OPERATOR_EQ, 0)

                );

                if( myFieldCode != null ) {

                    myColumnName = Objects.toString(Identifier.name(myFieldCode), null);

                }

                Code foreingFieldCode = getCode(

                        where,

                        new ImmutablePair<>(OPERATOR_EQ, 1),

                        new ImmutablePair<>(FUNCTION_GETATTR, 1)

                );

                if( foreingFieldCode != null ) {

                    foreignColumnName = Objects.toString(Constant.value(foreingFieldCode), null);

                }

                return new String[] { myColumnName, tableName,foreignColumnName };

            } catch(Throwable t) {

                LOGGER.warn("Can't get table and code from expression '"+expression.getPhrase()+"' in toMany controller",t);

                return null;

            }

        }

        private Code getCode(Code code, Pair<String,Integer>... args) {

            for (Pair<String, Integer> arg : args) {

                if( !StringUtils.equalsIgnoreCase(Callable.name(code),arg.getLeft()) ) {

                    return null;

                }

                code = Callable.parameters(code).get(arg.getRight());

            }

            return code;

        }

        private String getTableName() {

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

            if( StringUtils.isBlank(s) ) {

                return null;

            }

            return s;

        }

        public void setEditable(boolean editable) {

            this.cboRelationType.setEnabled(editable);

            this.pickerMyField.setEditable(editable);

            this.cboTable.setEnabled(editable);

            this.pickerForeignField.setEditable(editable);

            this.pickerExpression.setEditable(editable);

            this.editable = editable;

        }

        public void setEnabled(boolean enabled) {

            if( !editable ) {

                enabled =  false;

            }

            this.cboRelationType.setEnabled(enabled);

            this.pickerMyField.setEnabled(enabled);

            this.cboTable.setEnabled(enabled);

            this.pickerForeignField.setEnabled(enabled);

            this.pickerExpression.setEditable(enabled);

        }

        public void clean() {

            this.cboRelationType.setSelectedIndex(-1);

            this.pickerMyField.clean();

            this.cboTable.setSelectedIndex(-1);

            this.pickerForeignField.clean();

            this.pickerExpression.set(null);

        }

        public void put(FeatureAttributeDescriptor descriptor) {

            if (descriptor == null) {

                this.clean();

                return;

            }

            boolean prevDisableEvents = this.disableEvents;

            try {

                this.disableEvents = true;

                this.pickerMyField.setFeatureType(descriptor.getFeatureType());

                ListElement.setSelected(this.cboRelationType, descriptor.getRelationType());

                FeatureAttributeEmulator attrEmulator = descriptor.getFeatureAttributeEmulator();

                if (attrEmulator instanceof FeatureAttributeEmulatorExpression) {

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

                    String[] fieldsAndTable = this.getFieldsAndTable(expression);

                    if (fieldsAndTable == null) {

                        this.cboTable.setSelectedIndex(-1);

                        this.pickerForeignField.clean();

                        return;

                    }

                    this.pickerMyField.set(fieldsAndTable[0]);

                    this.cboTable.setSelectedItem(fieldsAndTable[1]);

                    doTableChanged();

                    this.pickerForeignField.set(fieldsAndTable[2]);

                    this.pickerExpression.set(expression);

                } else {

                    this.clean();

                }

            } catch (Throwable t) {

                LOGGER.warn("Can't set attribute descriptor in toMany controller",t);

            } finally {

                this.disableEvents = prevDisableEvents;

            }

        }

        public void fetch(EditableFeatureAttributeDescriptor descriptor) {

            if( descriptor == null ) {

                this.clean();

                return;

            }

//            Expression exp = this.pickerExpression.get();

//            if( ExpressionUtils.isPhraseEmpty(exp) ) {

//                descriptor.setFeatureAttributeEmulator((Expression)null);

//            } else {

//                descriptor.setFeatureAttributeEmulator(exp);

//            }

            Tags tags = descriptor.getTags();

            if( !tags.has(DAL_RELATED_TABLE) ) {

                String tableName =  this.getTableName();

                if( StringUtils.isNotBlank(tableName) ) {

                    tags.set(DAL_RELATED_TABLE, tableName);                    

                }

            }

            if( !tags.has(DAL_RELATED_UNIQUE_FIELD_NAME) ) {

                String tableName = tags.getString(DAL_RELATED_TABLE, null);

                if( StringUtils.isNotBlank(tableName) ) {

                    try {

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

                        FeatureType ft = repository.getFeatureType(tableName);

                        FeatureAttributeDescriptor[] pk = ft.getPrimaryKey();

                        if( !ArrayUtils.isEmpty(pk) && pk.length==1 ) {

                            tags.set(DAL_RELATED_UNIQUE_FIELD_NAME, pk[0].getName());

                        }

                    } catch(Throwable t) {

                        LOGGER.warn("Can't get primary key of table '"+tableName+"'.",t);

                    }

                }

            }

        }

        public Expression getExpression() {

            Expression exp = this.pickerExpression.get();

            if( ExpressionUtils.isPhraseEmpty(exp) ) {

                return null;

            } else {

                return exp;

            }

        }

        public int getRelationType() {

            Object n = this.cboRelationType.getSelectedItem();

            if( n == null ) {

                return DynField.RELATION_TYPE_NONE;

            }

            return ((LabeledValue<Integer>)n).getValue();

        }

    }

    private static class AvailableValuesController {

        private final JList lstValues;

        private final JTextComponent txtLabel;

        private final JTextComponent txtValue;

        private final JButton btnAdd;

        private final JButton btnUpdate;

        private final JButton btnRemove;

        private final JButton btnRemoveAll;

        public AvailableValuesController(

                JList lstValues,

                JTextComponent txtLabel,

                JTextComponent txtValue,

                JButton btnAdd,

                JButton btnUpdate,

                JButton btnRemove,

                JButton btnRemoveAll

        ) {

            this.lstValues = lstValues;

            this.txtLabel = txtLabel;

            this.txtValue = txtValue;

            this.btnAdd = btnAdd;

            this.btnUpdate = btnUpdate;

            this.btnRemove = btnRemove;

            this.btnRemoveAll = btnRemoveAll;

            this.lstValues.addListSelectionListener((ListSelectionEvent e) -> {

              doValuesChanged();

            });

            this.btnAdd.addActionListener((ActionEvent e) -> {

              doAdd();

            });

            this.btnUpdate.addActionListener((ActionEvent e) -> {

              doUpdate();

            });

            this.btnRemove.addActionListener((ActionEvent e) -> {

              doRemove();

            });

            this.btnRemoveAll.addActionListener((ActionEvent e) -> {

              doRemoveAll();

            });

        }

        public void clean() {

            this.lstValues.setModel(new DefaultListModel());

            this.txtLabel.setText("");

            this.txtValue.setText("");

            this.lstValues.setSelectedIndex(-1);

        }

        public DynObjectValueItem[] get() {

            ListModel<DynObjectValueItem> model = this.lstValues.getModel();

            if( model.getSize()==0 ) {

              return null;

            }

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

            DefaultListModel model = new DefaultListModel();

            if (availableValues != null) {

                for (DynObjectValueItem availableValue : availableValues) {

                    model.addElement(availableValue);

                }

            }

            this.lstValues.setModel(model);

            if (model.getSize() > 0) {

                this.lstValues.setSelectedIndex(0);

            } else {

                this.lstValues.setSelectedIndex(-1);

            }

        }

        public void setEditable(boolean editable) {

            this.lstValues.setEnabled(editable);

            this.txtLabel.setEditable(editable);

            this.txtValue.setEditable(editable);

            this.btnAdd.setEnabled(editable);

            this.btnUpdate.setEnabled(editable);

            this.btnRemove.setEnabled(editable);

            this.btnRemoveAll.setEnabled(editable);

        }

        private void doValuesChanged() {

            DynObjectValueItem value = (DynObjectValueItem) this.lstValues.getSelectedValue();

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

            DefaultListModel model = (DefaultListModel) this.lstValues.getModel();

            model.addElement(value);

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

        }

        private void doUpdate() {

            DynObjectValueItem value = (DynObjectValueItem) this.lstValues.getSelectedValue();

            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.lstValues.getSelectedIndex();

            if (n < 0) {

                return; // EEhh?? esto no deberia pasar

            }

            DefaultListModel model = (DefaultListModel) this.lstValues.getModel();

            model.removeElementAt(n);

            if (--n < 0) {

                n = 0;

            }

            this.lstValues.setSelectedIndex(n);

        }

        private void doRemoveAll() {

            DefaultListModel model = new DefaultListModel();

            this.lstValues.setModel(model);

            this.lstValues.setSelectedIndex(-1);

        }

    }

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

    private CalculatorController<Integer> pickerPrecision;

    private CalculatorController<Integer> pickerScale;

    private PickerController<Locale> pickerLocale;

    private PickerController<IProjection> pickerCRS;

    private ExpressionPickerController pickerVirtualFieldGetter;

    private ExpressionPickerController pickerVirtualFieldSetter;

    private ExpressionPickerController pickerDefaultFormat;

    private CalculatorController<Integer> pickerOrder;

    private AvailableValuesController availableValuesController;

    private AggregateController<Tag> tagsController;

    private ToOneController toOneController;

    private ExpressionPickerController pickerValuesFilter;

    private int mode;

    private FeatureStoreElement featureStoreElement;

    public DefaultFeatureAttributePanel() {

        this.mode = FeatureTypePanel.MODE_SHOW_ONLY;

        DataTypesManager dataManager = ToolsLocator.getDataTypesManager();

        // se deber?a de utilizar el datatypepicker

        this.fieldTypes = new ArrayList<>();

        fieldTypes.add( new ListElement<>("Decimal", DataTypes.DECIMAL) );

        fieldTypes.add( new ListElement<>("Integer", DataTypes.INTEGER) );

        fieldTypes.add( new ListElement<>("Long", DataTypes.LONG) );

        fieldTypes.add( new ListElement<>("String", DataTypes.STRING) );

        fieldTypes.add( new ListElement<>("Boolean", DataTypes.BOOLEAN) );

        fieldTypes.add( new ListElement<>("Date", DataTypes.DATE) );

        fieldTypes.add( new ListElement<>("Date/Time (Timestamp)", DataTypes.TIMESTAMP) );

//        for (DataType dataType : dataManager) {

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

//        }

        fieldTypes.sort((ListElement<Integer> o1, ListElement<Integer> o2) -> 

                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((ListElement<Integer> o1, ListElement<Integer> o2) -> 

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

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

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

        this.geometrySubtypes.sort((ListElement<Integer> o1, ListElement<Integer> o2) -> 

                o1.toString().compareTo(o2.toString())

        );

        this.initComponents();

    }

    private void initComponents() {

        final ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        final ExpressionEvaluatorSwingManager evaluatorSwingManager = ExpressionEvaluatorSwingLocator.getManager();

        final DataSwingManager dataSwingManager = DALSwingLocator.getSwingManager();

        final DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

        this.translate();

        ToolsSwingUtils.ensureMaxRows(this.gridAttrTagsTable, 10);

        this.splAttrTags = ToolsSwingUtils.createVerticalSplit(

                this.grdAttrTags,

                this.gridAttrTagsTable, false,

                this.gridAttrTagsItem, true

        );

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

        for (ListElement<Integer> element : fieldTypes) {

            modelTypes.addElement(element);

        }

        this.cboFieldType.setModel(modelTypes);

        this.cboFieldType.setRenderer(new DefaultListCellRenderer() {

          @Override

          public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

              JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

              label.setIcon(null);

              try {

                DataType dataType = dataTypeManager.get((int) value);

                IconTheme theme = ToolsSwingLocator.getIconThemeManager().getCurrent();

                if (theme.exists(dataType.getIconName())) {

                    label.setIcon(theme.get(dataType.getIconName()));

                }

              } catch(Exception ex) {

                // Do nothing, ignore

              }

              return label;

          }

        });

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

        swingManager.addClearButton(this.txtDefaultFormat);

        swingManager.addClearButton(this.txtFieldName);

        swingManager.addClearButton(this.txtIntervalEnd);

        swingManager.addClearButton(this.txtIntervalStart);

        swingManager.addClearButton(this.txtScale);

        swingManager.addClearButton(this.txtSize);

        swingManager.addClearButton(this.txtDisplaySize);

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

        swingManager.setDefaultPopupMenu(this.txtFieldName);

        swingManager.setDefaultPopupMenu(this.txtIntervalEnd);

        swingManager.setDefaultPopupMenu(this.txtIntervalStart);

        swingManager.setDefaultPopupMenu(this.txtScale);

        swingManager.setDefaultPopupMenu(this.txtSize);

        swingManager.setDefaultPopupMenu(this.txtDisplaySize);

        swingManager.setDefaultPopupMenu(this.cboDateFormat);

        swingManager.setDefaultPopupMenu(this.cboFieldType);

        swingManager.setDefaultPopupMenu(this.cboGeometrySubtype);

        swingManager.setDefaultPopupMenu(this.cboGeometryType);

        swingManager.setDefaultPopupMenu(this.cboDataProfile);

//        swingManager.setDefaultPopupMenu(this.cboRelationToOneCodeName);

//        swingManager.setDefaultPopupMenu(this.cboRelationToOneTableName);

//        swingManager.setDefaultPopupMenu(this.cboRelationToManyForeignFieldName);

//        swingManager.setDefaultPopupMenu(this.cboRelationToManyTableName);

        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.toOneController = new ToOneController(

                txtRelationToOneMyFieldName,

                cboRelationToOneType, 

                chkRelationToOneIsClosedList, 

                cboRelationToOneTableName, 

                cboRelationToOneCodeName, 

                cboRelationToOneFormula, 

                btnRelationToOneFormula,

                btnRelationToOneFormulaBookmarks,

                btnRelationToOneFormulaHistory

        );

        this.toManyController = new ToManyController(

                cboRelationToManyType, 

                cboRelationToManyMyFieldName, 

                cboRelationToManyTableName, 

                cboRelationToManyForeignFieldName, 

                txtRelationToManyExpression, 

                btnRelationToManyExpression,

                btnRelationToManyExpressionHistory,

                btnRelationToManyExpressionBookmarks

        );

        this.pickerIntervalEnd = swingManager.createDatePickerController(

                this.txtIntervalEnd,

                this.btnIntervalEnd

        );

        this.pickerIntervalStart = swingManager.createDatePickerController(

                this.txtIntervalStart,

                this.btnIntervalStart

        );

        this.pickerSize = evaluatorSwingManager.createCalculatorController(

                this.txtSize, DataTypes.INT

        );

        this.pickerDisplaySize = evaluatorSwingManager.createCalculatorController(this.txtDisplaySize, DataTypes.INT

        );

        this.pickerPrecision = evaluatorSwingManager.createCalculatorController(

                this.txtPrecision, DataTypes.INT

        );

        this.pickerScale = evaluatorSwingManager.createCalculatorController(

                this.txtScale, DataTypes.INT

        );

        this.pickerLocale = swingManager.createLocalePickerController(this.cboLocale);

        this.txtDefaultValue.getComponentPopupMenu().add(evaluatorSwingManager.createJExpressionBuilderAction(txtDefaultValue));

        this.pickerOrder = evaluatorSwingManager.createCalculatorController(

                this.txtOrder, DataTypes.INT

        );

        this.availableValuesController = new AvailableValuesController(

                lstAvailableValues,

                txtAvailableValuesLabel,

                txtAvailableValuesValue,

                btnAvailableValuesAdd,

                btnAvailableValuesUpdate,

                btnAvailableValuesRemove,

                btnAvailableValuesRemoveAll

        );

        this.tagsController = new DefaultAggregateController<>(

                this.tblAttrTagsItems,

                this.btnAttrTagsModify,

                this.btnAttrTagsDiscard,

                this.btnAttrTagsAccept,

                this.btnAttrTagsNew,

                this.btnAttrTagsDelete,

                new TagController(

                        this.cboAttrTagsItemName,

                        this.cboAttrTagsItemValue,

                        this.lblAttrTagsItemNotesValue

                )

        );        

        this.txtMinValue.setEnabled(false);

        this.txtMaxValue.setEnabled(false);

        this.btnVirtualFieldGetter.setText("");

        this.featureStoreElement = dataSwingManager.createFeatureStoreElement();

        this.pickerVirtualFieldGetter = evaluatorSwingManager.createExpressionPickerController(

                txtVirtualFieldGetter, btnVirtualFieldGetter, btnVirtualFieldBookmarksGetter, btnVirtualFieldHistoryGetter

        );

        this.pickerVirtualFieldGetter.getConfig().addElement(this.featureStoreElement);

        this.pickerVirtualFieldSetter = evaluatorSwingManager.createExpressionPickerController(

                txtVirtualFieldSetter, btnVirtualFieldSetter, btnVirtualFieldBookmarksSetter, btnVirtualFieldHistorySetter

        );

        this.pickerVirtualFieldSetter.getConfig().addElement(this.featureStoreElement);

        this.chkVirtualField.addChangeListener((ChangeEvent e) -> {

          if (chkVirtualField.isSelected()) {

            pickerVirtualFieldGetter.setEditable(mode==MODE_EDIT_ALL || mode==MODE_EDIT_ONLY_METADATA || mode==MODE_VIRTUAL_FIELD);

            pickerVirtualFieldSetter.setEditable(false);

          } else {

            pickerVirtualFieldGetter.setEditable(false);

            pickerVirtualFieldSetter.setEditable(false);

          }

        });

        this.pickerCRS = dataSwingManager.createProjectionPickerController(

                this.txtCRS, this.btnCRS

        );

        this.cboFieldType.addItemListener((ItemEvent e) -> {

          SwingUtilities.invokeLater(() -> {

            doFieldTypeChanged();

          });

        });

        this.pickerPrecision.addChangeListener((ChangeEvent e) -> {

          doCheckPrecisionAndScale();

        });

        this.pickerScale.addChangeListener((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);

        this.btnFieldType.addActionListener((ActionEvent e) -> {

          doDataTypeSelection();

        });

        this.pickerValuesFilter = evaluatorSwingManager.createExpressionPickerController(

                txtValuesFilter, btnValuesFilter, btnValuesFilterBookmarks, btnValuesFilterHistory

        );

        this.pickerValuesFilter.getConfig().addElement(this.featureStoreElement);

        this.chkIsAutomatic.addActionListener((ActionEvent e) -> {

            doIsAutomaticChanged();

        });

        this.rdbRelationNone.addItemListener((ItemEvent e) -> { doChangeRelationType(); });

        this.rdbRelationToOne.addItemListener((ItemEvent e) -> { doChangeRelationType(); });

        this.rdbRelationToMany.addItemListener((ItemEvent e) -> { doChangeRelationType(); });

        this.chkDefaultValue.addActionListener((ActionEvent e) -> {

            txtDefaultValue.setEditable(!chkDefaultValue.isSelected());

        });

        SwingUtilities.invokeLater( () -> {

                splAttrTags.setDividerLocation(0.4);

            }

        );

    }

    private void translate() {

        final ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        final I18nManager i18n = ToolsLocator.getI18nManager();

        swingManager.translate(this.lblAllowNulls);

        swingManager.translate(this.lblCRS);

        swingManager.translate(this.lblDataProfile);

        swingManager.translate(this.lblDateFormat);

        swingManager.translate(this.lblDefaultValue);

        swingManager.translate(this.chkDefaultValue);

        swingManager.translate(this.lblDefaultFormat);

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

        swingManager.translate(this.lblIsReadOnly);

        swingManager.translate(this.lblIsPrimaryKey);

        swingManager.translate(this.lblPrecision);

        swingManager.translate(this.lblScale);

        swingManager.translate(this.lblSize);

        swingManager.translate(this.lblDisplaySize);

        swingManager.translate(this.chkVirtualField);

        swingManager.translate(this.lblVirtualField);

        swingManager.translate(this.lblVirtualFieldSep);

        swingManager.translate(this.lblVirtualFieldGetter);

        swingManager.translate(this.lblVirtualFieldSetter);

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

        swingManager.translate(this.lblAttrTagsItemName);

        swingManager.translate(this.lblAttrTagsItemValue);

        swingManager.translate(this.lblAttrTagsItemNotes);

        swingManager.translate(this.lblValuesFilter);

        swingManager.translate(this.lblRelationRepository);

        swingManager.translate(this.lblRelationNone);

        swingManager.translate(this.lblRelationToOne);

        swingManager.translate(this.lblRelationToMany);

        swingManager.translate(this.lblRelationToOneType);

        swingManager.translate(this.lblRelationToOneCondition);

        swingManager.translate(this.lblRelationToOneLabelFormula);

        swingManager.translate(this.lblRelationToOneIsClosedList);

        swingManager.translate(this.lblRelationToManyType);

        swingManager.translate(this.lblRelationToManyExpression);

        swingManager.translate(this.lblRelationToManyCondition);

//        swingManager.translate(this.chkIsForeingKey);

        swingManager.translate(this.txtDisplaySize);

        swingManager.translate(this.txtPrecision);

        swingManager.translate(this.txtScale);

        swingManager.translate(this.txtScale);

        swingManager.translate(this.lblLocale);

        swingManager.translate(this.rdbRelationToMany);

        this.lblRelationToMany.setText( this.lblRelationToMany.getText() +

                "  ("+

                i18n.getTranslation("_Requires_that_it_be_a_calculated_field_of_list_type") +

                ")"

                );

    }

    private int getRelationType() {

        if( this.rdbRelationNone.isSelected() ) {

            return DynField.RELATION_TYPE_NONE;

        } 

        if( this.rdbRelationToOne.isSelected() ) {

            return this.toOneController.getRelationType();

        } 

        if( this.rdbRelationToMany.isSelected() ) {

            return this.toManyController.getRelationType();

        }

        return DynField.RELATION_TYPE_NONE;

    }

    private void doChangeRelationType() {

        boolean enabled;

        switch(this.getMode() ) {

            case MODE_EDIT_ONLY_METADATA:

            case MODE_EDIT_ALL:

            case MODE_VIRTUAL_FIELD:

                enabled = true;

                break;

            case MODE_SHOW_ONLY:

            default:

                enabled = false;

                break;

        }

        this.rdbRelationNone.setEnabled(enabled);

        this.rdbRelationToOne.setEnabled(enabled && !this.isVirtualField());

        this.rdbRelationToMany.setEnabled(enabled && (this.isVirtualField() || this.getDataType().getType()==DataTypes.LIST));

        if( this.rdbRelationNone.isSelected() ) {

            this.pickerVirtualFieldGetter.setEnabled(enabled);

            this.toOneController.setEnabled(false);

            this.toManyController.setEnabled(false);

        } else if( this.rdbRelationToOne.isSelected() ) {

            this.pickerVirtualFieldGetter.setEnabled(enabled);

            this.toManyController.setEnabled(false);

            if( this.isVirtualField() ) {

                this.rdbRelationNone.setSelected(true);

            } else {

                this.toOneController.setEditable(enabled);

                this.toOneController.setEnabled(enabled);

            }

        } else if( this.rdbRelationToMany.isSelected() ) {

            if( !this.isVirtualField() || this.getDataType().getType()!=DataTypes.LIST ) {

                this.rdbRelationNone.setSelected(true);

            } else {

                this.pickerVirtualFieldGetter.setEnabled(false);

                this.toOneController.setEnabled(false);