Application: gvSIG desktop

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

import java.awt.Dimension;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import javax.swing.ImageIcon;

import javax.swing.JComponent;

import javax.swing.ListCellRenderer;

import javax.swing.ListModel;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.event.ListSelectionEvent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.swing.ExpressionPickerController;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

import org.gvsig.fmap.dal.swing.DALSwingLocator;

import org.gvsig.fmap.dal.swing.DataSwingManager;

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

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

import org.gvsig.fmap.dal.swing.impl.expressionevaluator.FeatureStoreElementFactory;

import org.gvsig.tools.locator.ReferenceNotRegisteredException;

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

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

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

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.icontheme.IconTheme;

import org.gvsig.tools.util.LabeledValue;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureAttributesSelectionPanel 

        extends DefaultFeatureAttributesSelectionPanelView

        implements FeatureAttributesSelectionPanel 

    {

    private static final String ATTR_IS_EXPRESSION = "DefaultFeatureAttributesSelectionPanel_isExpression";

    private FeatureType featureType;

    private final ActionListenerSupport actionListenerSupport;

    private FilteredListController availableFieldsController;

    private final List<FeatureAttributeDescriptor> selecteds;

    private ExpressionPickerController expressionPicker = null;

    private boolean allowCalculatedAttributes = false;

    private List<EditableFeatureAttributeDescriptor> extraColumns;

    private List<String> selectedNames;

    public DefaultFeatureAttributesSelectionPanel() {

        this.actionListenerSupport = ToolsSwingLocator.getToolsSwingManager().createActionListenerSupport();

        this.selecteds = new ArrayList<>();

        this.initComponents();

    }

    private void initComponents() {

        ToolsSwingManager toolsSwingManager = ToolsSwingLocator.getToolsSwingManager();

        ListCellRenderer renderer = DALSwingLocator.getDataSwingManager().createDefaultFeatureAttributeListCellRenderer();

//        DefaultListCellRenderer renderer = new DefaultListCellRenderer();

        this.lstAvailableColumns.setCellRenderer(renderer);

        this.lstSelectedColumns.setCellRenderer(renderer);

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

          if( e.getValueIsAdjusting() ) {

            return;

          }

          doSelectAvailableColumn();

        });

        this.lstAvailableColumns.addMouseListener(new MouseAdapter() {

            @Override

            public void mouseClicked(MouseEvent e) {

                if( e.getClickCount()==2 ) {

                    doColumnAdd();

                }

            }

        });

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

          if( e.getValueIsAdjusting() ) {

            return;

          }

          doSelectColumn();

        });

        this.txtExpression.getDocument().addDocumentListener(new DocumentListener() {

            public void changedUpdate(DocumentEvent e) {

              doSelectAvailableColumn();

            }

            @Override

            public void insertUpdate(DocumentEvent de) {

                 doSelectAvailableColumn();

            }

            @Override

            public void removeUpdate(DocumentEvent de) {

                 doSelectAvailableColumn();

            }

        });

        this.txtExpression.addFocusListener(new FocusAdapter() {

            @Override

            public void focusGained(FocusEvent e) {

                lstAvailableColumns.getSelectionModel().clearSelection();

            }

        });

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

          doColumnAdd();

        });

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

          doColumnRemove();

        });

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

          doColumnDown();

        });

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

          doColumnUp();

        });

        this.availableFieldsController = toolsSwingManager.createFilteredListController(

                lstAvailableColumns, 

                txtColumnsFilter, 

                btnColumnsFilter

        );     

        Dimension sz = this.getPreferredSize();

        if( sz.width<450 ) {

            sz.width = 450;

        }

        if( sz.height < 320 ) {

            sz.height = 320;

        }

        this.setPreferredSize(sz);

    }

    @Override

    public List<String> getSelectedNames() {

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

        for (FeatureAttributeDescriptor selected : selecteds) {

                names.add(selected.getName());

        }

      return names;

    }

    @Override

    public void setSelectedNames(List<String> names) {

        this.selecteds.clear();

        if (names != null) {

            this.selectedNames = new ArrayList<>(names);

            for (String name : names) {

                FeatureAttributeDescriptor attr = this.getAttributeDescriptor(name);

                if(attr == null){

                    if(this.allowCalculatedAttributes && !ExpressionUtils.isValidIdentifier(name)){

                        attr = createAttributeFromExpression(name);

                    } else {

                        continue;

                    }

                } 

                if (selectedContains(attr)) {

                    continue;

                }

                this.selecteds.add(attr);

            }

        } else {

            this.selectedNames = new ArrayList<>();

        }

        updateControls();

    }

    private boolean selectedContains(FeatureAttributeDescriptor attr) {

        for (FeatureAttributeDescriptor selected : selecteds) {

            if(StringUtils.equalsIgnoreCase(selected.getName(), attr.getName())){

                return true;

            }

        }

        return false;

    }

    private void doSelectAvailableColumn() {

        if( this.lstAvailableColumns.getSelectedIndex()>=0 || !this.expressionPicker.isEmpty()) {

            this.btnColumnAdd.setEnabled(true);

            return;

        }

        this.btnColumnAdd.setEnabled(false);

    }

    private void doSelectColumn() {

        int indexSelecteds = this.lstSelectedColumns.getSelectedIndex();

        ListModel modelSelecteds = this.lstSelectedColumns.getModel();

        this.btnColumnUp.setEnabled(indexSelecteds >= 1);

        this.btnColumnDown.setEnabled(indexSelecteds>=0 && indexSelecteds < modelSelecteds.getSize() - 1);

        if( this.lstSelectedColumns.getSelectedIndex()>=0 ) {

//            FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) this.lstSelectedColumns.getSelectedValue();

//            if( attr != null ) {

//              this.selecteds.add(attr.getName());

              this.btnColumnRemove.setEnabled(true);

//              this.btnColumnDown.setEnabled(true);

//              this.btnColumnUp.setEnabled(true);

              return;

//            }

        }

        this.btnColumnRemove.setEnabled(false);

//        this.btnColumnDown.setEnabled(false);

//        this.btnColumnUp.setEnabled(false);

    }

    private void doColumnUp() {

        LabeledValue attr = (LabeledValue) this.lstSelectedColumns.getSelectedValue();

        if( attr == null ) {

            return;

        }

        int n = this.selecteds.indexOf(attr.getValue());

        if( n<1 ) {

          return;

        }

        Collections.swap(selecteds, n, n-1);

        this.lstSelectedColumns.setSelectedIndex(n-1);

        this.updateControls();

    }

    private void doColumnDown() {

        LabeledValue attr = (LabeledValue) this.lstSelectedColumns.getSelectedValue();

        if( attr == null ) {

            return;

        }

        int n = this.selecteds.indexOf(attr.getValue());

        if( n<0 || n>=this.selecteds.size()-1 ) {

          return;

        }

        Collections.swap(selecteds, n, n+1);

        this.lstSelectedColumns.setSelectedIndex(n+1);

        this.updateControls();

    }

    private boolean checkIfAttributeInFeatureType(String myAttr) {

        for (FeatureAttributeDescriptor attr : featureType) {

            if(attr.getName().equalsIgnoreCase(myAttr) ) {

               return true;

            }

        }

        List<EditableFeatureAttributeDescriptor> columns = featureType.getExtraColumns().getColumns();

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

            for (EditableFeatureAttributeDescriptor extraCol : columns) {

                if(extraCol.getName().equalsIgnoreCase(myAttr)) {

                    return true;

                }

            }

        }

        if (this.extraColumns!=null && !extraColumns.isEmpty()) {

            for (EditableFeatureAttributeDescriptor extraCol : extraColumns) {

                if(extraCol.getName().equalsIgnoreCase(myAttr)) {

                    return true;

                }

            }

        }

        return false;

    }

    private void doColumnRemove() {

        FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) this.lstSelectedColumns.getSelectedValue();

        if( attr == null ) {

            return;

        }

        int n = this.selecteds.indexOf(attr);

        if( n<0 ) {

          return;

        }

        if(attr.getTags().getBoolean(ATTR_IS_EXPRESSION,false)){

            Expression toExp = ExpressionEvaluatorLocator.getManager().createExpression();

            toExp.setPhrase(attr.getLabel());

            this.expressionPicker.set(toExp);

        }

        this.selecteds.remove(n);

        this.updateControls();

    }

    private void doColumnAdd() {

        if(this.lstAvailableColumns.getSelectedIndex() >= 0) {

            FeatureAttributeDescriptor attr = (FeatureAttributeDescriptor) this.lstAvailableColumns.getSelectedValue();

            if( attr == null ) {

                return;

            }

            int n = this.selecteds.indexOf(attr);

            if( n>=0 ) {

              return;

            }

            this.selecteds.add(attr);

        } else if(!this.expressionPicker.isEmpty()) {

            if (this.expressionPicker.isValid()) {

                Expression exp = this.expressionPicker.get();

                String expressionField = exp.getPhrase();

                FeatureAttributeDescriptor attr = createAttributeFromExpression(expressionField);

                for (FeatureAttributeDescriptor selected : this.selecteds) {

                    if(StringUtils.equals(attr.getName(),selected.getName())){

                        return;

                    }

                }

                this.selecteds.add(attr);

                this.expressionPicker.set(null);

            }

        }

        this.updateControls();

    }

    private FeatureAttributeDescriptor createAttributeFromExpression(String expressionField) {

        EditableFeatureAttributeDescriptor attr = DALLocator.getDataManager().createFeatureAttributeDescriptor(expressionField, DataTypes.STRING);

        attr.getTags().set(ATTR_IS_EXPRESSION, true);

        attr.setLabel(expressionField);

        return attr;

    }

    @Override

    public void setStore(FeatureStore store) {

        try {

            this.setFeatureType(store.getDefaultFeatureType());

        } catch (DataException ex) {

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

        }

    }

    @Override

    public void setFeatureType(FeatureType featureType) {

        this.featureType = featureType;

        if(this.selectedNames != null){

            this.setSelectedNames(this.selectedNames);

        }  else {

            this.updateControls();

        }

    }

    @Override

    public void setExtraColumns(List<EditableFeatureAttributeDescriptor> extraColumns) {

        this.extraColumns = extraColumns;

        if(this.selectedNames != null){

            this.setSelectedNames(this.selectedNames);

        }  else {

            this.updateControls();

        }

    }

    @Override

    public FeatureType getFeatureType() {

        return this.featureType;

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    @Override

    public void addActionListener(ActionListener al) {

        this.actionListenerSupport.addActionListener(al);

    }

    @Override

    public ActionListener[] getActionListeners() {

        return this.actionListenerSupport.getActionListeners();

    }

    @Override

    public void removeActionListener(ActionListener al) {

        this.actionListenerSupport.removeActionListener(al);

    }

    @Override

    public void removeAllActionListener() {

        this.actionListenerSupport.removeAllActionListener();

    }

    @Override

    public void fireActionEvent(ActionEvent ae) {

        this.actionListenerSupport.fireActionEvent(ae);

    }

    @Override

    public boolean hasActionListeners() {

        return this.actionListenerSupport.hasActionListeners();

    }

    private void updateControls() {

        if (this.expressionPicker == null) {

                this.expressionPicker = 

                DALSwingLocator.getDataSwingManager().createExpressionPickerController(

                        this.featureType.getStore(), 

                        txtExpression, 

                        btnExpression, 

                        btnBookmarks, 

                        btnHistory);

        }

        int indexAvailables = this.lstAvailableColumns.getSelectedIndex();

        int indexSelecteds = this.lstSelectedColumns.getSelectedIndex();

        FilteredListModel modelAvailables = ToolsSwingLocator.getToolsSwingManager().createFilteredListModel();

        FilteredListModel modelSelecteds = ToolsSwingLocator.getToolsSwingManager().createFilteredListModel();

        DataSwingManager dataSwingManager = DALSwingLocator.getDataSwingManager();

        List<FeatureAttributeDescriptor> availables = new ArrayList<>();

        for (FeatureAttributeDescriptor attr : featureType) {

            if (!selectedContains(attr)) {

                availables.add(attr);

            }

        }

        List<EditableFeatureAttributeDescriptor> columns = featureType.getExtraColumns().getColumns();

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

            for (EditableFeatureAttributeDescriptor extraCol : columns) {

                if (!selectedContains(extraCol)) {

                    availables.add(extraCol);

                }

            }

        }

        if (this.extraColumns!=null && !this.extraColumns.isEmpty()) {

            for (FeatureAttributeDescriptor extraCol : this.extraColumns) {

                if (!selectedContains(extraCol)) {

                    availables.add(extraCol);

                }

            }

        }

        DataSwingManager dalSwingManager = DALSwingLocator.getDataSwingManager();

        Collections.sort(availables, (FeatureAttributeDescriptor o1, FeatureAttributeDescriptor o2) -> StringUtils.compare(

                dalSwingManager.getAttributeDescriptorLabel(o1),

                dalSwingManager.getAttributeDescriptorLabel(o2)

        ));

        for (FeatureAttributeDescriptor available : availables) {

            modelAvailables.addElement(available);

        }

        modelAvailables.setFilter(this.txtColumnsFilter.getText());

        modelAvailables.sort(true);

        for (FeatureAttributeDescriptor attr : this.selecteds) {

            modelSelecteds.addElement(attr);

        }

        modelAvailables.sort(true);

        this.lstAvailableColumns.setModel(modelAvailables);

        this.lstSelectedColumns.setModel(modelSelecteds);

        if( indexAvailables >= 0 && modelAvailables.getSize()>0 ) {

            if( indexAvailables >= modelAvailables.getSize() ) {

                indexAvailables = modelAvailables.getSize()-1;

            }

            this.lstAvailableColumns.setSelectedIndex(indexAvailables);

            this.btnColumnAdd.setEnabled(true);

        } else {

            if(!this.expressionPicker.isEmpty()) {

                this.btnColumnAdd.setEnabled(true);  

            } else {

                this.btnColumnAdd.setEnabled(false);

            }

        }

        this.btnColumnUp.setEnabled(indexSelecteds >= 1);

        this.btnColumnDown.setEnabled(indexSelecteds>=0 && indexSelecteds < modelSelecteds.getSize() - 1);

        if( indexSelecteds >= 0 && modelSelecteds.getSize()>0 ) {

            if( indexSelecteds >= modelSelecteds.getSize() ) {

                indexSelecteds = modelSelecteds.getSize()-1;

            }

            this.lstSelectedColumns.setSelectedIndex(indexSelecteds);

            this.lstSelectedColumns.ensureIndexIsVisible(indexSelecteds);

            this.btnColumnRemove.setEnabled(true);

        } else {

            this.btnColumnRemove.setEnabled(false);

        }

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        return ToolsSwingUtils.loadImage(this, imageName);

    }

    public static void selfRegister() {

//        boolean n = ToolsSwingUtils.registerIcons( 

//                DefaultFeatureAttributesSelectionPanel.class,

//                null,

//                LIBRARY_NAME,

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

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

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

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

//        );          

    }

    @Override

    public void allowCalculatedAttributes(boolean allowCalculatedAttributes) {

        this.allowCalculatedAttributes = allowCalculatedAttributes;

        this.btnBookmarks.setVisible(this.allowCalculatedAttributes);

        this.btnHistory.setVisible(this.allowCalculatedAttributes);

        this.btnExpression.setVisible(this.allowCalculatedAttributes);

        this.txtExpression.setVisible(this.allowCalculatedAttributes);

    }

    private FeatureAttributeDescriptor getAttributeDescriptor(String name) {

        if(this.featureType == null){

            return null;

        }

        FeatureAttributeDescriptor attr = this.featureType.getAttributeDescriptorFromAll(name);

        if(attr != null){

            return attr;

        }

        if(this.extraColumns == null){

            return null;

        }

        for (EditableFeatureAttributeDescriptor extraColumn : this.extraColumns) {

            if(StringUtils.equalsIgnoreCase(extraColumn.getName(), name)){

                return extraColumn;

            }

        }

        return null;

    }

}