Application: gvSIG desktop

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

import org.gvsig.fmap.dal.swing.impl.featuretype.featurerule.FeatureRulesModel;

import org.gvsig.fmap.dal.swing.impl.featuretype.featurerule.FeatureRuleController;

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

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

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.Objects;

import javax.swing.AbstractAction;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

import javax.swing.JSplitPane;

import javax.swing.SwingUtilities;

import javax.swing.event.ChangeListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.event.TableModelEvent;

import javax.swing.table.AbstractTableModel;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.configurableactions.ConfigurableActionsMamager;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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

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

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

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

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

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

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

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

import org.gvsig.texteditor.JTextEditor;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynStruct_v2;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

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

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.threadsafedialogs.ThreadSafeDialogsManager;

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

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

import org.gvsig.tools.util.ToolsUtilLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureTypePanel 

        extends DefaultFeatureTypePanelView

        implements FeatureTypePanel

    {

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

    private FeatureType originalFeatureType = null;

    private JSplitPane splRules;

    private JSplitPane splAttributes;

    private FeatureRuleController ruleController;

    private JSplitPane splTags;

    private class FeatureTypeTableModel extends AbstractTableModel {

        private final FeatureType featureType;

        private final String[] columnNames = new String[] {

          "Name",

          "Type",

          "Size",

          "Precision",

          "Scale",

          "Default value",

          "Calculated",

          "Fk"

        };

        private final Class[] columnClasses = new Class[] {

          String.class,

          String.class,

          Integer.class,

          Integer.class,

          Integer.class,

          String.class,

          Boolean.class,

          Boolean.class

        };

        public FeatureTypeTableModel() {

            this.featureType = null;

        }

        public FeatureTypeTableModel(FeatureType featureType) {

            this.featureType = featureType;

        }

        @Override

        public int getRowCount() {

            if( this.featureType==null ) {

                return 0;

            }

            return this.featureType.size();

        }

        @Override

        public int getColumnCount() {

            if( this.featureType==null ) {

                return 0;

            }

            return this.columnNames.length;

        }

        @Override

        public String getColumnName(int columnIndex) {

            if( this.featureType==null ) {

                return "";

            }

            return this.columnNames[columnIndex];

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            if( this.featureType==null ) {

                return String.class;

            }

            return this.columnClasses[columnIndex];

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            return false;

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            if( this.featureType==null ) {

                return "";

            }

            FeatureAttributeDescriptor descriptor = this.featureType.getAttributeDescriptor(rowIndex);

            DataType dataType = descriptor.getDataType();

            switch(columnIndex) {

                case 0:

                    return descriptor.getName();

                case 1:

                    return descriptor.getDataTypeName();

                case 2:

                    if( dataType.supportSize() ) {

                      return descriptor.getSize();

                    }

                    return null;

                case 3:

                    if( dataType.supportPrecision()) {

                      return descriptor.getPrecision();

                    }

                    return null;

                case 4:

                    if( dataType.supportScale()) {

                      return descriptor.getScale();

                    }

                    if( dataType.isNumeric() ) {

                      return 0;

                    }

                    return null;

                case 5:

                    return Objects.toString(descriptor.getDefaultValue(),"");

                case 6:

                    return descriptor.isComputed();

                case 7:

                    return descriptor.isForeingKey();

                default:

                    return "";

            }

        }

        @Override

        public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

        }

        public void fireUpdateEvent() {

            this.fireTableChanged(new TableModelEvent(this));

        }

    }

    public static class ViewAsJsonAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public ViewAsJsonAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_View_as_Json"));

            this.putValue(ACTION_COMMAND_KEY, "ViewAsJson");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_View_as_Json");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            DefaultFeatureTypePanel featureTypePanel = (DefaultFeatureTypePanel) e.getSource();

            FeatureType featureType = featureTypePanel.fetch(null);

            JTextEditor editor = ToolsSwingLocator.getTextEditorManager().createTextEditor();

            editor.setContents(featureType.toJsonBuilder().toString());

            WindowManager winmanager = ToolsSwingLocator.getWindowManager();

            winmanager.showWindow(

                    editor.asJComponent(), 

                    "FeatureType - "+featureType.getName(), 

                    WindowManager.MODE.WINDOW

            );

        }

    }

    public static class ForceSynchronizeAction extends AbstractAction {

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public ForceSynchronizeAction() {

            I18nManager i18n = ToolsLocator.getI18nManager();

            this.putValue(NAME, i18n.getTranslation("_Force_synchronize"));

            this.putValue(ACTION_COMMAND_KEY, "ForceSynchronize");

        }

        @Override

        public Object getValue(String key) {

            if (NAME.equals(key)) {

                // Cuando se registra la accion aun no se han cargado las traducciones

                I18nManager i18n = ToolsLocator.getI18nManager();

                return i18n.getTranslation("_Force_synchronize");

            }

            return super.getValue(key);

        }

        @Override

        public void actionPerformed(ActionEvent e) {

            DefaultFeatureTypePanel featureTypePanel = (DefaultFeatureTypePanel) e.getSource();

            featureTypePanel.featureType.forceStrongChanges();

        }

    }

    private DefaultFeatureAttributePanel descriptorPanel;

    private EditableFeatureType featureType;

    private int mode;

    private FeatureTypeTableModel tableModel;

    private FeatureStore store;

    private int currentRow;

    private boolean fieldSelectionAllowed;

    private AggregateController<Tag> tagsController;

    private ChangeListenerHelper changeListenerHelper;

    private AggregateController<FeatureRule> rulesController;

    public DefaultFeatureTypePanel() {

        this.mode = MODE_SHOW_ONLY;

        this.currentRow = -1;

        this.fieldSelectionAllowed = true;

        this.initComponents();

    }

    @SuppressWarnings("Convert2Lambda")

    private void initComponents() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        ConfigurableActionsMamager cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        JComponent c = cfgActionsManager.getConfigurableActionsComponent(CONFIGURABLE_PANEL_ID, this);

        this.pnlCfgActions.setLayout(new BorderLayout(0,0));

        this.pnlCfgActions.add(c, BorderLayout.CENTER);

        this.splRules = ToolsSwingUtils.createVerticalSplit(

                this.gridRules, 

                this.gridRulesTable, false,

                this.gridRulesDetail, true

        );

        this.splAttributes = ToolsSwingUtils.createVerticalSplit(

                this.gridAttributes,

                this.gridAttributesTable, false,

                this.gridAttributesDetail, true

        );

        this.splTags = ToolsSwingUtils.createVerticalSplit(

                this.gridTags,

                this.gridTagsItems, false,

                this.gridTagsItem, true

        );

        this.changeListenerHelper = swingManager.createChangeListenerHelper();

        swingManager.translate(this.btnDelete);

        swingManager.translate(this.btnFormFieldAccept);

        swingManager.translate(this.btnFormFieldDiscard);

        swingManager.translate(this.btnFormFieldModify);

        swingManager.translate(this.btnNew);

        swingManager.translate(this.lblLabel);

        swingManager.translate(this.lblDescription);

        swingManager.translate(this.lblTags);

        swingManager.translate(this.tabFeatureType);

        swingManager.translate(this.lblRulesDefaultRules);

        swingManager.translate(this.lblRulesCustomRules);

        swingManager.translate(this.chkRulesValidateFeatureBeforeInsert);

        swingManager.translate(this.chkRulesValidateFeaturesAtFinishEditing);

        swingManager.translate(this.lblRuleName);

        swingManager.translate(this.lblRuleDescription);

        swingManager.translate(this.lblRuleCheckAtFinishEditing);

        swingManager.translate(this.lblRuleCheckAtUpdate);

        swingManager.translate(this.lblRuleValidation);

        swingManager.translate(this.btnRulesNew);

        swingManager.translate(this.btnRulesDelete);

        swingManager.translate(this.btnRuleFormFieldModify);

        swingManager.translate(this.btnRuleFormFieldAccept);

        swingManager.translate(this.btnRuleFormFieldDiscard);

        swingManager.translate(this.btnRuleValidation);

        swingManager.translate(this.btnRuleValidationBookmarks);

        swingManager.translate(this.btnRuleValidationHistory);

        swingManager.translate(this.lblTagsItemName);

        swingManager.translate(this.lblTagsItemValue);

        swingManager.translate(this.lblTagsItemNotes);

        this.tableModel = new FeatureTypeTableModel();

        this.tblFields.setModel(this.tableModel);

        this.tblFields.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent e) {

                if( e.getValueIsAdjusting() ) {

                    return;

                }

                doChangeFieldSelection();

            }

        });

        this.descriptorPanel = new DefaultFeatureAttributePanel();

        this.pnlField.setLayout(new BorderLayout());

        this.pnlField.add(this.descriptorPanel, BorderLayout.CENTER);

        this.descriptorPanel.setEnabled(false);

        this.btnFormFieldModify.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doFormFieldModify();

            }

        });

        this.btnFormFieldDiscard.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doFormFieldDiscard();

            }

        });

        this.btnFormFieldAccept.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doFormFieldAccept();

            }

        });

        this.btnNew.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doNewField();

            }

        });

        this.btnDelete.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doDeleteField();

            }

        });

        this.tagsController = new DefaultAggregateController<>(

                this.tblTagsItems,

                this.btnTagsModify,

                this.btnTagsDiscard,

                this.btnTagsAccept,

                this.btnTagsNew,

                this.btnTagsDelete,

                new TagController(

                        this.cboTagsItemName,

                        this.cboTagsItemValue,

                        this.lblTagsItemNotesValue

                )

        );

        this.ruleController = new FeatureRuleController(

                txtRuleName,

                txtRuleDescription,

                chkRuleCheckAtFinishEditing,

                chkRuleCheckAtUpdate,

                txtRuleValidation,

                btnRuleValidation,

                btnRuleValidationBookmarks, 

                btnRuleValidationHistory

        );

        this.rulesController = new DefaultAggregateController<>(

                this.tblRules, 

                this.btnRuleFormFieldModify, 

                this.btnRuleFormFieldDiscard, 

                this.btnRuleFormFieldAccept, 

                this.btnRulesNew, 

                this.btnRulesDelete,

                ruleController

        );

        if( this.tblFields.getRowCount()>0 ) {

            this.tblFields.getSelectionModel().setSelectionInterval(0, 0);

            doFormFieldPut();

        }

        this.tabFeatureType.setSelectedIndex(1);

        ToolsSwingUtils.ensureRowsCols(this, 30, 120, 45, 150);

        SwingUtilities.invokeLater( () -> {

                splAttributes.setDividerLocation(0.3);

            }

        );

    }

    private boolean doFormFieldFetch() {

        int row = this.tblFields.getSelectedRow();

        if (row < 0) {

            return true;

        }

        FeatureAttributeDescriptor descriptor = this.featureType.getAttributeDescriptor(row);

        int previousType = descriptor.getType();

        if (descriptor instanceof EditableFeatureAttributeDescriptor) {

            if (this.descriptorPanel.fetch((EditableFeatureAttributeDescriptor) descriptor) == null) {

                return false;

            }

            this.tableModel.fireUpdateEvent();

        }

        FeatureAttributeDescriptor oldDescriptor = null;

        if (this.originalFeatureType != null) {

            oldDescriptor = this.originalFeatureType.getAttributeDescriptor(descriptor.getName());

        }

        if (oldDescriptor != null

                && oldDescriptor.getDataType() != descriptor.getDataType()

                && previousType != descriptor.getType()) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            I18nManager i18manager = ToolsLocator.getI18nManager();

            StringBuilder message = new StringBuilder();

            String[] messageArgs = new String[]{oldDescriptor.getName()};

            message.append(i18manager.getTranslation("_Already_existed_a_field_named_XfieldnameX_but_with_different_data_type", messageArgs));

            message.append(".\n");

            message.append(i18manager.getTranslation("_Values_of_data_will_try_to_coerce_to_this_type"));

            dialogs.messageDialog(

                    message.toString(),

                    null,

                    i18manager.getTranslation("_Values_will_change"),

                    JOptionPane.INFORMATION_MESSAGE,

                    "feature-type-manager-field-already-exist-in-previous-schema");

        }

        return true;

    }

    private void doFormFieldPut() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

        FeatureAttributeDescriptor descriptor = this.featureType.getAttributeDescriptor(row);

        this.currentRow = row;

        this.descriptorPanel.put(descriptor);

        updateButtonState();

        if( descriptor instanceof EditableFeatureAttributeDescriptor ) {

            this.btnFormFieldModify.setEnabled((this.mode==MODE_EDIT_ALL || this.mode==MODE_EDIT_ONLY_METADATA) && this.tblFields.getSelectedRowCount()==1);

        } else {

            this.btnFormFieldModify.setEnabled(false);

        }

    }

    private void updateButtonState() {

        this.descriptorPanel.setEnabled(true);

        this.descriptorPanel.setMode(MODE_SHOW_ONLY);

        this.btnFormFieldAccept.setEnabled(false);

        this.btnFormFieldDiscard.setEnabled(false);

        switch(this.mode) {

            case MODE_EDIT_ALL:

                this.btnDelete.setEnabled(true);

                this.btnFormFieldModify.setEnabled(true);

                this.btnNew.setEnabled(true);

                this.tagsController.setEnabled(true);

                this.rulesController.setEnabled(true);

                this.txtLabel.setEditable(true);

                this.txtDescription.setEditable(true);

                break;

            case MODE_EDIT_ONLY_METADATA:

                this.btnDelete.setEnabled(this.descriptorPanel.isVirtualField());

                this.btnFormFieldModify.setEnabled(true);

                this.btnNew.setEnabled(true);

                this.tagsController.setEnabled(true);

                this.rulesController.setEnabled(true);

                this.txtLabel.setEditable(true);

                this.txtDescription.setEditable(true);

                break;

            case MODE_SHOW_ONLY:

                this.btnDelete.setEnabled(false);

                this.btnFormFieldModify.setEnabled(false);

                this.btnNew.setEnabled(false);

                this.tagsController.setEnabled(false);

                this.rulesController.setEnabled(false);

                this.txtLabel.setEditable(false);

                this.txtDescription.setEditable(false);

                break;

        }

    }

    private void doFormFieldModify() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

        FeatureAttributeDescriptor descriptor = this.featureType.getAttributeDescriptor(row);

        this.descriptorPanel.put(descriptor);

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

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

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

        this.btnFormFieldModify.setEnabled(false);

        this.btnNew.setEnabled(false);

        this.btnDelete.setEnabled(false);

        if( descriptor instanceof EditableFeatureAttributeDescriptor ) {

            this.descriptorPanel.setMode(this.mode);

        } else {

            this.descriptorPanel.setMode(MODE_SHOW_ONLY);

        }

        this.fieldSelectionAllowed = false;

        this.changeListenerHelper.fireEvent();

    }

    @Override

    public boolean isEditing() {

        return btnFormFieldAccept.isEnabled() || this.rulesController.isEditing();

    }

    private void doFormFieldAccept() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

        if( doFormFieldFetch() ) {

            this.updateButtonState();

            this.tblFields.getSelectionModel().setSelectionInterval(row, row);

            this.tblFields.scrollRectToVisible(this.tblFields.getCellRect(row, 0, true));

            this.fieldSelectionAllowed = true;

        }

        this.changeListenerHelper.fireEvent();

    }

    private void doFormFieldDiscard() {

        doFormFieldPut();

        this.updateButtonState();

        this.fieldSelectionAllowed = true;

        this.changeListenerHelper.fireEvent();

    }

    private void doChangeFieldSelection() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

        if( !this.fieldSelectionAllowed ) {

            if( row !=this.currentRow ) {

                I18nManager i18n = ToolsLocator.getI18nManager();

                JOptionPane.showMessageDialog(

                    this, 

                    i18n.getTranslation("_Before_changing_field_accept_or_discard_the_changes"), 

                    i18n.getTranslation("_Warning"), 

                    JOptionPane.WARNING_MESSAGE

                );

                this.tblFields.getSelectionModel().setSelectionInterval(

                        this.currentRow, 

                        this.currentRow

                );

            }

            return;

        }

        doFormFieldPut();   

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public int getMode() {

        return this.mode;

    }

    @Override

    public void setMode(int mode) {

        this.mode = mode;

        updateButtonState();

    }

    @Override

    public EditableFeatureType fetch(EditableFeatureType type) {

        if( type == null ) {

            type = (EditableFeatureType) this.featureType.getCopy();

        } else {

            type.removeAll();

            type.copyFrom(this.featureType);

        }

        type.setLabel(

            StringUtils.defaultIfBlank(this.txtLabel.getText(), null)

        );

        type.setDescription(

            StringUtils.defaultIfBlank(this.txtDescription.getText(), null)

        );

        this.tagsController.getModel().fetch(type.getTags());

        type.setCheckFeaturesAtInsert(this.chkRulesValidateFeatureBeforeInsert.isSelected());

        type.setCheckFeaturesAtFinishEditing(this.chkRulesValidateFeaturesAtFinishEditing.isSelected());

        return type;

    }

    @Override

    public void put(FeatureType type) {

        this.featureType = null;

        this.originalFeatureType = null;

        if (type == null) {

            this.store = null;

            this.rulesController.clean();

            this.tagsController.clean();

            this.chkRulesValidateFeatureBeforeInsert.setSelected(true);

            this.chkRulesValidateFeaturesAtFinishEditing.setSelected(false);

        } else {

            FeatureType ftypeToCompare = type.getOriginalFeatureType();

            if (ftypeToCompare == null) {

                ftypeToCompare = type;

            }

            this.originalFeatureType = ftypeToCompare.getCopy();

            this.featureType = (EditableFeatureType) type.getCopy();

            this.rulesController.setModel(new FeatureRulesModel(this.featureType.getRules()));

            this.chkRulesValidateFeatureBeforeInsert.setSelected(type.isCheckFeaturesAtInsert());

            this.chkRulesValidateFeaturesAtFinishEditing.setSelected(type.isCheckFeaturesAtFinishEditing());

            // Nos quedamos una referencia para evitar que se destruya, ya que

            // el featureType se guarda solo una WeakReference.

            this.store = type.getStore();

            this.ruleController.setFeatureStore(this.store);

            this.txtLabel.setText(

                    StringUtils.defaultIfBlank(((DynStruct_v2) type).getLabel(), "")

            );

            this.txtDescription.setText(

                    StringUtils.defaultIfBlank(((DynStruct_v2) type).getDescription(), "")

            );

            this.tagsController.setModel( new TagsModel(((DynStruct_v2) type).getTags()));

        }

        if( !(type instanceof EditableFeatureType) ) {

            this.setMode(MODE_SHOW_ONLY);

        }

        this.tableModel = new FeatureTypeTableModel(this.featureType);

        this.tblFields.setModel(this.tableModel);

        if( type!=null && !type.isEmpty() ) {

            this.tblFields.getSelectionModel().setSelectionInterval(0, 0);

        }

        SwingUtilities.invokeLater(() -> {

            this.splAttributes.setDividerLocation(0.3);

        });

        updateButtonState();

        doFormFieldPut();       

    }

    private void doNewField() {

        EditableFeatureType eft = (EditableFeatureType)this.featureType;

        EditableFeatureAttributeDescriptor descriptor = eft.add(

                this.featureType.getNewFieldName(), 

                DataTypes.STRING,

                50

        );

        if( this.mode == MODE_EDIT_ONLY_METADATA ) {

            descriptor.setFeatureAttributeEmulator(ExpressionUtils.createExpression("NULL"));

        }

        this.tableModel.fireUpdateEvent();

        int row = descriptor.getIndex();

        this.tblFields.getSelectionModel().addSelectionInterval(row,row);

        this.tblFields.scrollRectToVisible(this.tblFields.getCellRect(row, 0, true));

        updateButtonState();

        this.descriptorPanel.put(descriptor);

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

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

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

        this.btnFormFieldModify.setEnabled(false);

        this.btnNew.setEnabled(false);

        this.btnDelete.setEnabled(false);

        if (descriptor instanceof EditableFeatureAttributeDescriptor) {

            if(this.mode == MODE_EDIT_ONLY_METADATA) {

                this.descriptorPanel.setMode(FeatureTypeAttributePanel.MODE_VIRTUAL_FIELD);

            } else {

                this.descriptorPanel.setMode(this.mode);

            }

        } else {

            this.descriptorPanel.setMode(MODE_SHOW_ONLY);

        }

        this.fieldSelectionAllowed = false;

        this.changeListenerHelper.fireEvent();

    }

    private void doDeleteField() {

        int row = this.tblFields.getSelectedRow();

        int[] rows = this.tblFields.getSelectedRows();

        ArrayList FeatureAttributeDescriptor;

        ArrayList<String> descriptors = new ArrayList<>();

        for (int rowDescriptor : rows) {

            if (rowDescriptor < 0) {

                continue;

            }

            descriptors.add(this.featureType.getAttributeDescriptor(rowDescriptor).getName());

        }

        for (String descriptor : descriptors) {

            ((EditableFeatureType)this.featureType).remove(descriptor);

        }

        this.tableModel.fireUpdateEvent();

        if( row >= this.tblFields.getRowCount()) {

            row = this.tblFields.getRowCount()-1;

        }

        this.tblFields.getSelectionModel().addSelectionInterval(row,row);

        updateButtonState();

        doFormFieldPut();       

        this.changeListenerHelper.fireEvent();

    }

    @Override

    public void addChangeListener(ChangeListener listener) {

        this.changeListenerHelper.addChangeListener(listener);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return this.changeListenerHelper.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener listener) {

        this.changeListenerHelper.removeChangeListener(listener);

    }

    @Override

    public void removeAllChangeListener() {

        this.changeListenerHelper.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return this.changeListenerHelper.hasChangeListeners();

    }

  public static void selfRegister() {

        ConfigurableActionsMamager cfgActionsManager;

        try {

            cfgActionsManager = ToolsUtilLocator.getConfigurableActionsMamager();

        } catch(ReferenceNotRegisteredException ex) {

            return;

        }

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new ViewAsJsonAction());

        cfgActionsManager.addConfigurableAction(CONFIGURABLE_PANEL_ID, new ForceSynchronizeAction());

  }

}