Application: gvSIG desktop

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

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.List;

import javax.swing.DefaultListModel;

import javax.swing.DefaultListSelectionModel;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.ListModel;

import javax.swing.ListSelectionModel;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.ListSelectionEvent;

import javax.swing.text.JTextComponent;

import org.apache.commons.lang.StringUtils;

import org.gvsig.expressionevaluator.Expression;

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.exception.DataException;

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

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

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

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

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.featurequery.FeatureQueryCalculatedColumnsPanel;

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

import static org.gvsig.fmap.dal.swing.impl.DefaultDALSwingLibrary.LIBRARY_NAME;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypes;

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

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureQueryCalculatedColumnsPanel

        extends DefaultFeatureQueryCalculatedColumnsPanelView

        implements FeatureQueryCalculatedColumnsPanel {

    private class AttributeListElement extends ListElement<FeatureAttributeDescriptor> {

        public AttributeListElement(FeatureAttributeDescriptor value) {

            super(value.getLabel(), value);

        }

        @Override

        public String getLabel() {

            return ((FeatureAttributeDescriptor) this.getValue()).getName();

        }

    }

    private class ColumnController implements DocumentListener, ChangeListener, ActionListener {

        private final JTextComponent txtName;

        private final JComboBox cboDataType;

        private final JButton btnDataType;

        private final JButton btnExpressionBookmarks;

        private final JButton btnExpressionHistory;

        private final JButton btnExpression;

        private final JTextComponent txtExpression;

        private ExpressionPickerController expPicker;

        private DataTypePickerController pickerDataType;

        private boolean hasChanges;

        private final JTextComponent txtSize;

        private final JTextComponent txtPrecision;

        private final JTextComponent txtScale;

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

        private final JButton btnColumnMore;

        private final JButton btnApplyChanges;

        public ColumnController(

                JTextComponent txtName,

                JComboBox cboDataType,

                JButton btnDataType,

                JTextComponent txtExpression,

                JButton btnExpression,

                JButton btnExpressionHistory,

                JButton btnExpressionBookmarks,

                JTextComponent txtSize,

                JTextComponent txtPrecision,

                JTextComponent txtScale,

                JButton btnApplyChanges,

                JButton btnColumnMore

        ) {

            this.txtName = txtName;

            this.cboDataType = cboDataType;

            this.btnDataType = btnDataType;

            this.txtExpression = txtExpression;

            this.btnExpression = btnExpression;

            this.btnExpressionHistory = btnExpressionHistory;

            this.btnExpressionBookmarks = btnExpressionBookmarks;

            this.txtSize = txtSize;

            this.txtPrecision = txtPrecision;

            this.txtScale = txtScale;

            this.btnApplyChanges = btnApplyChanges;

            this.btnColumnMore = btnColumnMore;

            this.hasChanges = false;

            this.initComponents();

            this.setEnabled(false);

        }

        public void initComponents() {

            this.pickerDataType = ToolsSwingLocator.getToolsSwingManager().createDataTypePickerController(this.cboDataType, this.btnDataType, false);

            ExpressionEvaluatorSwingManager managerExpSwing = ExpressionEvaluatorSwingLocator.getManager();

            this.expPicker = managerExpSwing.createExpressionPickerController(

                    txtExpression,

                    btnExpression,

                    btnExpressionBookmarks,

                    btnExpressionHistory

            );

            this.txtName.getDocument().addDocumentListener(this);

            this.cboDataType.addActionListener(this);

            this.txtExpression.getDocument().addDocumentListener(this);

            this.txtSize.getDocument().addDocumentListener(this);

            this.txtPrecision.getDocument().addDocumentListener(this);

            this.txtScale.getDocument().addDocumentListener(this);

            //Todo: que el listener expresion lo gestion el picker

            this.cboDataType.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent ae) {

                    doSetDefaultValuesForDataType();

                    doEnabledByDataType();

                }

            });

        }

        public void doEnabledByDataType() {

            JComboBox comboBox = cboDataType;

            if (comboBox.getSelectedItem()==null) {

                return;

            }

            DataType dataType = (DataType) comboBox.getSelectedItem();

            txtSize.setEnabled(dataType.supportSize());

            txtPrecision.setEnabled(dataType.supportPrecision());

            txtScale.setEnabled(dataType.supportScale());

        }

        public void doSetDefaultValuesForDataType() {

            if (this.cboDataType.getSelectedItem()==null) {

                return;

            }

            DataType dataType = (DataType) this.cboDataType.getSelectedItem();

            if (dataType.supportSize() && txtSize.getText().isEmpty()) {

                txtSize.setText(String.valueOf(dataType.getDefaultSize()));

            } else if (!dataType.supportSize()) {

                txtSize.setText("");

            }

            if (dataType.supportPrecision() && txtPrecision.getText().isEmpty()) {

                txtPrecision.setText(String.valueOf(dataType.getDefaultPrecision()));

            } else if (!dataType.supportPrecision()) {

                txtPrecision.setText("");

            }

            if (dataType.supportScale() && txtScale.getText().isEmpty()) {

                txtScale.setText(String.valueOf(dataType.getDefaultScale()));

            } else if (!dataType.supportScale()) {

                txtScale.setText("");

            }

        }

        public boolean hasChanges() {

            return this.hasChanges;

        }

        public void setEnabled(boolean enabled) {

            this.txtName.setEnabled(enabled);

            this.expPicker.setEnabled(enabled);

            this.cboDataType.setEnabled(enabled);

            this.txtSize.setEnabled(enabled);

            this.txtPrecision.setEnabled(enabled);

            this.txtScale.setEnabled(enabled);

            this.btnApplyChanges.setEnabled(enabled);

            this.btnColumnMore.setEnabled(enabled);

        }

        public void clean() {

            this.txtName.setText("");

            this.expPicker.set(null);

            this.cboDataType.setSelectedIndex(0);

            this.txtSize.setText("");

            this.txtPrecision.setText("");

            this.txtScale.setText("");

            this.btnApplyChanges.setEnabled(false);

            this.btnColumnMore.setEnabled(false);

            this.hasChanges = false;

        }

        public void put(EditableFeatureAttributeDescriptor attr) {

            this.clean();

            this.txtName.setText(attr.getName());

            FeatureAttributeEmulatorExpression emu = (FeatureAttributeEmulatorExpression) attr.getFeatureAttributeEmulator();

            if (emu != null) {

                try {

                    this.expPicker.set(emu.getExpression().clone());

                } catch (CloneNotSupportedException ex) {

                    LOGGER.warn("Not able to clone expression.", ex);

                    throw new RuntimeException(ex);

                }

            }

            this.pickerDataType.set(attr.getDataType());

            Coercion coerceString = ToolsLocator.getDataTypesManager().get(DataTypes.STRING).getCoercion();

            txtSize.setEnabled(attr.getDataType().supportSize());

            if (attr.getDataType().supportSize()) {

                try {

                    this.txtSize.setText((String) coerceString.coerce(attr.getSize()));

                } catch (CoercionException ex) {

                    LOGGER.warn("Not able to coerce text to integer from size box.", ex);

                }

            }

            txtPrecision.setEnabled(attr.getDataType().supportPrecision());

            if (attr.getDataType().supportPrecision()) {

                try {

                    this.txtPrecision.setText((String) coerceString.coerce(attr.getPrecision()));

                } catch (CoercionException ex) {

                    LOGGER.warn("Not able to coerce text to integer from precision box.", ex);

                }

            }

            txtScale.setEnabled(attr.getDataType().supportScale());

            if (attr.getDataType().supportScale()) {

                try {

                    this.txtScale.setText((String) coerceString.coerce(attr.getScale()));

                } catch (CoercionException ex) {

                    LOGGER.warn("Not able to coerce text to integer from scale box.", ex);

                }

            }

//            doEnabledByDataType();

            this.btnColumnMore.setEnabled(true);

            this.btnApplyChanges.setEnabled(false);

            this.hasChanges = false;

        }

        public EditableFeatureAttributeDescriptor fetch(EditableFeatureAttributeDescriptor attr) {

            attr.setName(this.txtName.getText());

            try {

                Expression exp = this.expPicker.get();

                if (exp!=null) {

                    attr.setFeatureAttributeEmulator(exp.clone());

                } else {

                    attr.setFeatureAttributeEmulator((Expression) null);

                }

            } catch (CloneNotSupportedException ex) {

                LOGGER.warn("Not able to clone expression.", ex);

                throw new RuntimeException(ex);

            }

            attr.setDataType(this.pickerDataType.get());

            Coercion coerceInteger = ToolsLocator.getDataTypesManager().get(DataTypes.INTEGER).getCoercion();

            try {

                if (attr.getDataType().supportSize()) {

                    attr.setSize((int) coerceInteger.coerce(this.txtSize.getText()));

                }

            } catch (CoercionException ex) {

                LOGGER.warn("Not able to coerce text to integer from size box.", ex);

            }

            try {

                if (attr.getDataType().supportPrecision()) {

                    attr.setPrecision((int) coerceInteger.coerce(this.txtPrecision.getText()));

                }

            } catch (CoercionException ex) {

                LOGGER.warn("Not able to coerce text to integer from precision box.", ex);

            }

            try {

                if (attr.getDataType().supportScale()) {

                    attr.setScale((int) coerceInteger.coerce(this.txtScale.getText()));

                }

            } catch (CoercionException ex) {

                LOGGER.warn("Not able to coerce text to integer from scale box.", ex);

            }

            this.hasChanges = false;

            this.btnColumnMore.setEnabled(true);

            this.btnApplyChanges.setEnabled(false);

            return attr;

        }

        private void doHasChanges() {

            this.btnColumnMore.setEnabled(false);

            this.btnApplyChanges.setEnabled(true);

            this.hasChanges = true;

        }

        @Override

        public void insertUpdate(DocumentEvent de) {

            doHasChanges();

        }

        @Override

        public void removeUpdate(DocumentEvent de) {

            doHasChanges();

        }

        @Override

        public void changedUpdate(DocumentEvent de) {

            doHasChanges();

        }

        @Override

        public void stateChanged(ChangeEvent ce) {

            doHasChanges();

        }

        @Override

        public void actionPerformed(ActionEvent ae) {

            doHasChanges();

        }

        public void setStore(FeatureStore store) {

          DALSwingLocator.getManager().configureExpressionBuilder(expPicker.getConfig(), store);

//             FeatureStoreElement calculatedStoreElement = DALSwingLocator.getSwingManager()

//                    .createFeatureStoreElement();

//            calculatedStoreElement.setFeatureStore(store);

//            this.expPicker.removeAllSymbolTables();

//            this.expPicker.addElement(calculatedStoreElement);

        }

    }

    private ColumnController columnController;

    private FeatureStore store;

    private FeatureType featureType;

    private FeatureQuery query;

//    private JExpressionBuilder pckExpression;

    private static final String COLUMN_DEFAULT_NAME = "Field";

    private EditableFeatureAttributeDescriptor actualEditableAttribute;

    private DefaultListModel lstAttributesModel;

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

    public DefaultFeatureQueryCalculatedColumnsPanel() {

        this.columnController = null;

        this.initComponents();

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        return ToolsSwingUtils.loadImage(this, imageName);

    }

    @Override

    public void setStore(FeatureStore store) {

        try {

            this.featureType = store.getDefaultFeatureType();

            this.store = store;

            this.query = store.createFeatureQuery();

            this.columnController.setStore(store);

//            this.pckExpression = DALSwingLocator.getManager().createQueryFilterExpresion(store);

        } catch (DataException ex) {

            throw new RuntimeException("Can't assign store", ex);

        }

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

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

        ImageIcon icon = theme.get("picker-datatype");

        this.btnColumnDataType.setIcon(icon);

        toolsSwingManager.translate(this.lblExpression);

        toolsSwingManager.translate(this.lblName);

        toolsSwingManager.translate(this.lblType);

        toolsSwingManager.translate(this.lblSize);

        toolsSwingManager.translate(this.lblPrecision);

        toolsSwingManager.translate(this.lblScale);

        toolsSwingManager.translate(this.btnApplyChanges);

        toolsSwingManager.translate(this.btnColumnMore);

        this.columnController = new ColumnController(

                this.txtColumnName,

                this.cboColumnDataType,

                this.btnColumnDataType,

                this.txtColumnExpression,

                this.btnColumnExpression,

                this.btnColumnExpressionHistory,

                this.btnColumnExpressionBookmarks,

                this.txtColumnSize,

                this.txtColumnPrecision,

                this.txtColumnScale,

                this.btnApplyChanges,

                this.btnColumnMore

        );

//        this.lstAttributes.setCellRenderer(new FeatureAttributeListCellRenderer());

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

            if (e.getValueIsAdjusting()) {

                return;

            }

            doSelectAttribute();

        });

        Dimension sz = this.getPreferredSize();

        if (sz.width < DEFAULT_WIDTH) {

            sz.width = DEFAULT_WIDTH;

        }

        if (sz.height < DEFAULT_HEIGHT) {

            sz.height = DEFAULT_HEIGHT;

        }

        this.setPreferredSize(sz);

        this.lstAttributesModel = new DefaultListModel<ListElement<EditableFeatureAttributeDescriptor>>();

//        this.lstAttributesModel = ToolsSwingLocator.getToolsSwingManager().createFilteredListModel();

        this.lstAttributes.setModel(lstAttributesModel);

        this.lstAttributes.setSelectionModel(new DefaultListSelectionModel() {

            @Override

            public void setSelectionInterval(int index0, int index1) {

                if (checkColumnControllerHasChangesWithUser()) {

                    super.setSelectionInterval(index0, index1);

                    doSelectAttribute();

                }

            }

        });

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

            if (checkColumnControllerHasChangesWithUser()) {

                doAdd();

            }

        });

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

            doRemove();

        });

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

            doUp(lstAttributes);

        });

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

            doDown(lstAttributes);

        });

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

            doApplyChanges();

        });

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

            doColumnMore();

        });

    }

    private boolean checkColumnControllerHasChangesWithUser() {

        if (this.hasChanges()) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            String message = i18n.getTranslation("_Changes_has_not_been_saved_Are_you_sure_you_want_to_continue");

            String title = i18n.getTranslation("_Changes_not_saved");

            int r = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(message, title,

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE);

            if (r == JOptionPane.NO_OPTION) {

                return false;

            }

        }

        return true;

    }

    private void doColumnMore() {

        if (this.columnController == null) {

            return;

        }

        final I18nManager i18n = ToolsLocator.getI18nManager();

        WindowManager_v2 winManager = (WindowManager_v2) ToolsSwingLocator.getWindowManager();

        final FeatureTypeAttributePanel panel = DALSwingLocator.getSwingManager().createFeatureTypeAttributePanel();

        panel.clean();

        panel.setFeatureType(featureType);

        panel.put(actualEditableAttribute);

        panel.setMode(FeatureTypeAttributePanel.MODE_VIRTUAL_FIELD);

        final Dialog dialog = winManager.createDialog(

                panel.asJComponent(),

                i18n.getTranslation("_Extra_column"),

                null,

                WindowManager_v2.BUTTONS_OK_CANCEL

        );

        dialog.addActionListener((ActionEvent e) -> {

            if (dialog.getAction() != WindowManager_v2.BUTTONS_OK) {

                return;

            }

            try {

                FeatureAttributeDescriptor prev = actualEditableAttribute.getCopy();

                panel.fetch(actualEditableAttribute);

                columnController.put(actualEditableAttribute);

                if (!prev.equals(actualEditableAttribute)) {

                    columnController.doHasChanges();

                }

            } catch (Exception ex) {

                LOGGER.warn("Problems updating feature descriptor.", ex);

            }

        });

        dialog.show(WindowManager.MODE.DIALOG);

    }

    public boolean checkPanel(StringBuilder msg) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        if (this.hasChanges()) {

            int r = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(

                    i18n.getTranslation("_Changes_has_not_been_saved_Are_you_sure_you_want_to_continue"),

                    i18n.getTranslation("_Changes_not_saved"),

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE);

            if (r == JOptionPane.NO_OPTION) {

                return false;

            }

        }

        return true;

    }

    public boolean hasChanges() {

        return this.columnController.hasChanges();

    }

    private void doSelectAttribute() {

        int index = this.lstAttributes.getSelectedIndex();

        ListModel model = this.lstAttributesModel;

        this.btnUp.setEnabled(index >= 1);

        this.btnDown.setEnabled(index >= 0 && index < this.lstAttributesModel.getSize() - 1);

        EditableFeatureAttributeDescriptor value = null;

        if (this.lstAttributes.getSelectedValue() != null) {

            ListElement<EditableFeatureAttributeDescriptor> selectedValue = (ListElement<EditableFeatureAttributeDescriptor>) this.lstAttributes.getSelectedValue();

            if (selectedValue != null) {

                value = selectedValue.getValue();

            }

        }

        if (value == null) {

            this.columnController.clean();

            this.columnController.setEnabled(false);

            this.actualEditableAttribute = null;

        } else {

            //EditableFeatureAttributeDescriptor value = node.getValue();

            this.actualEditableAttribute = value;

            columnController.setEnabled(true);

            columnController.put(value);

        }

    }

    @Override

    public FeatureQuery fetch(FeatureQuery query) {

        if (hasChanges()) {

            I18nManager i18n = ToolsLocator.getI18nManager();

            String message = i18n.getTranslation("_Changes_has_not_been_saved_Do_you_want_to_save_them_before_continue");

            String title = i18n.getTranslation("_Changes_not_saved");

            int r = ToolsSwingLocator.getThreadSafeDialogsManager().confirmDialog(message, title,

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE);

            if (r == JOptionPane.YES_NO_OPTION) {

                doApplyChanges();

            }

        }

        if (query == null) {

            return this.query.getCopy();

        }

        this.query.getExtraColumn().clear();

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

            ListElement<EditableFeatureAttributeDescriptor> element = (ListElement<EditableFeatureAttributeDescriptor>) lstAttributesModel.get(i);

            EditableFeatureAttributeDescriptor newExtraColumn = this.query.getExtraColumn().add(element.getValue().getName(), element.getValue().getType());

            newExtraColumn.copyFrom(element.getValue());

        }

        query.copyFrom(this.query);

        return query;

    }

    @Override

    public FeatureQuery fetch() {

        return this.fetch(null);

    }

    @Override

    public void put(FeatureQuery query) {

        this.query.copyFrom(query);

        addExtraColumns(this.query);

    }

    private void addExtraColumns(FeatureQuery query) {

        List<EditableFeatureAttributeDescriptor> cols = query.getExtraColumn().getColumns();

        if (cols == null || cols.isEmpty()) {

            return;

        }

        for (EditableFeatureAttributeDescriptor col : cols) {

            ListElement lf = new AttributeListElement(col);

            this.lstAttributesModel.addElement(lf);

        }

        if (this.lstAttributesModel.getSize() > 0) {

            this.lstAttributes.setSelectedIndex(0);

        }

    }

    public static void selfRegister() {

//        boolean n = ToolsSwingUtils.registerIcons(

//                DefaultFeatureQueryOrderPanel.class,

//                null,

//                LIBRARY_NAME,

//                new String[]{ "featurequery", "featurequery-column-add"},

//                new String[]{ "featurequery", "featurequery-column-remove"},

//                new String[]{ "featurequery", "featurequery-column-down"},

//                new String[]{ "featurequery", "featurequery-column-up"}

//        );

    }

    private void doAdd() {

        int id = 0;

        String newName = COLUMN_DEFAULT_NAME;

        while (checkIfValueExistInModel(newName, this.lstAttributesModel)) {

            newName = COLUMN_DEFAULT_NAME + "_" + id;

            id += 1;

        }

        EditableFeatureAttributeDescriptor newAttr = DALLocator.getDataManager().createFeatureAttributeDescriptor(

                newName,

                DataTypes.STRING

        );

        if (newAttr.getDataType().supportSize()) {

            newAttr.setSize(newAttr.getDataType().getDefaultSize());

        }

        this.columnController.put(newAttr);

        this.columnController.setEnabled(true);

        this.lstAttributesModel.addElement(new AttributeListElement(newAttr));

        ListElement.setSelected(this.lstAttributes, newAttr);

        this.lstAttributes.revalidate();

        this.lstAttributes.repaint();

        this.actualEditableAttribute = newAttr;

    }

    private boolean checkIfValueExistInModel(String name, ListModel<ListElement<EditableFeatureAttributeDescriptor>> model) {

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

            EditableFeatureAttributeDescriptor element = model.getElementAt(i).getValue();

            if (StringUtils.equals(element.getLabel(), name)) {

                return true;

            }

        }

        return false;

    }

    private void doRemove() {

        AttributeListElement selectedValue = (AttributeListElement) this.lstAttributes.getSelectedValue();

        if( selectedValue == null ) {

            return;

        }

        FeatureAttributeDescriptor attr = selectedValue.getValue();

        if( attr == null ) {

            return;

        }

        boolean removeFromAggregateFunctions = false;

        boolean removeFromOrder = false;

        boolean removeFromGroupByColums = false;

        if( this.query.getAggregateFunctions().containsKey(attr.getName()) ) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            int n = dialogs.confirmDialog(

                    "El campo '"+attr.getName()+"' se esta usando en una funcion de agregado. ? Dese borrarlo igualmente ?",

                    "Eliminar campo",

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    "_FeatureQueryCalculatedColumns_remove_used_column"

            );

            if( n != JOptionPane.YES_OPTION ) {

                return;

            }

            n = dialogs.confirmDialog(

                    "? Desea eliminar la funcion de agregado donde se esta usando el campo '"+attr.getName()+"' ?",

                    "Eliminar campo",

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    "_FeatureQueryCalculatedColumns_remove_aggregate_function_when_remove_column"

            );

            if( n == JOptionPane.YES_OPTION ) {

                removeFromAggregateFunctions = true;

            } else {

                LOGGER.info("It has been decided not to delete the aggregate function of a deleted field");

            }

        }

        if( this.query.getGroupByColumns().contains(attr.getName()) ) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            int n = dialogs.confirmDialog(

                    "El campo '"+attr.getName()+"' se esta usando como campo de agrupacion. ? Dese borrarlo igualmente ?",

                    "Eliminar campo",

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    "_FeatureQueryCalculatedColumns_remove_used_column"

            );

            if( n != JOptionPane.YES_OPTION ) {

                return;

            }

            n = dialogs.confirmDialog(

                    "? Desea eliminar la agrupacion por el campo '"+attr.getName()+"' ?",

                    "Eliminar campo",

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    "_FeatureQueryCalculatedColumns_remove_group_by_column_when_remove_column"

            );

            if( n == JOptionPane.YES_OPTION ) {

                removeFromGroupByColums = true;

            } else {

                LOGGER.info("It has been decided not to delete the group by a deleted field");

            }

        }

        if( this.query.getOrder().contains(attr.getName()) ) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            int n = dialogs.confirmDialog(

                    "El campo '"+attr.getName()+"' se esta usando para establecer el orden. ? Dese borrarlo igualmente ?",

                    "Eliminar campo",

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    "_FeatureQueryCalculatedColumns_remove_used_column"

            );

            if( n != JOptionPane.YES_OPTION ) {

                return;

            }

            n = dialogs.confirmDialog(

                    "? Desea eliminar el uso del campo '"+attr.getName()+"' en la ordenacion ?",

                    "Eliminar campo",

                    JOptionPane.YES_NO_OPTION,

                    JOptionPane.QUESTION_MESSAGE,

                    "_FeatureQueryCalculatedColumns_remove_order_when_remove_column"

            );

            if( n == JOptionPane.YES_OPTION ) {

                removeFromOrder = true;

            } else {

                LOGGER.info("It has been decided not to delete the order by a deleted field");

            }

        }

        if( removeFromAggregateFunctions ) {

           this.query.removeAggregateFunction(attr.getName());

        }

        if( removeFromOrder ) {

            int index = this.query.getOrder().getIndex(attr.getName());

            this.query.getOrder().remove(index);

        }

        if( removeFromGroupByColums ) {

            this.query.removeGroupByColumn(attr.getName());

        }

        ListSelectionModel lsm = lstAttributes.getSelectionModel();

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

        int actualIndex = lsm.getMinSelectionIndex();

        this.lstAttributesModel.removeElement(selectedValue);

        this.columnController.clean();

        int size = model.size();

        if (size == 0) {

            //List is empty: disable delete, up, and down buttons.

        } else {

            //Adjust the selection.

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

            } else if (actualIndex >= model.getSize()) {

                lstAttributes.setSelectedIndex(model.getSize() - 1);

            } else {

                lstAttributes.setSelectedIndex(actualIndex);

            }

        }

    }

    private void doApplyChanges() {

        this.columnController.fetch(this.actualEditableAttribute);

        this.lstAttributes.invalidate();

        this.lstAttributes.repaint();

    }

    private void doUp(JList lstColumns) {

        int moveMe = lstColumns.getSelectedIndex();

        if (moveMe != 0) {

            //not already at top

            swap(lstColumns, moveMe, moveMe - 1);

            lstColumns.setSelectedIndex(moveMe - 1);

            lstColumns.ensureIndexIsVisible(moveMe - 1);

        }

    }

    private void doDown(JList lstColumns) {

        int moveMe = lstColumns.getSelectedIndex();

        if (moveMe != lstColumns.getModel().getSize() - 1) {

            //not already at bottom

            swap(lstColumns, moveMe, moveMe + 1);

            lstColumns.setSelectedIndex(moveMe + 1);

            lstColumns.ensureIndexIsVisible(moveMe + 1);

        }

    }

    private void swap(JList lstColumns, int a, int b) {

        DefaultListModel model = (DefaultListModel) lstColumns.getModel();

        Object aObject = model.getElementAt(a);

        Object bObject = model.getElementAt(b);

        model.set(a, bObject);

        model.set(b, aObject);

    }

}