Application: gvSIG desktop

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

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

import java.util.Objects;

import javax.swing.JComponent;

import javax.swing.JOptionPane;

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.fmap.dal.expressionevaluator.FeatureAttributeEmulatorExpression;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.i18n.I18nManager;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureTypePanel 

        extends FeatureTypePanelView

        implements FeatureTypePanel

    {

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

    private class FeatureTypeTableModel extends AbstractTableModel {

        private final FeatureType featureType;

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

          "Name",

          "Type",

          "Size",

          "Precision",

          "Default value",

          "Calculated"

        };

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

          String.class,

          String.class,

          Integer.class,

          Integer.class,

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

            switch(columnIndex) {

                case 0:

                    return descriptor.getName();

                case 1:

                    return descriptor.getDataTypeName();

                case 2:

                    return descriptor.getSize();

                case 3:

                    return descriptor.getPrecision();

                case 4:

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

                case 5:

                    return descriptor.isComputed();

                default:

                    return "";

            }

        }

        @Override

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

        }

        public void fireUpdateEvent() {

            this.fireTableChanged(new TableModelEvent(this));

        }

    }

    private DefaultFeatureTypeAttributePanel descriptorPanel;

    private FeatureType featureType;

    private boolean editable;

    private FeatureTypeTableModel tableModel;

    private FeatureStore store;

    private int currentRow;

    private boolean fieldSelectionAllowed;

    public DefaultFeatureTypePanel() {

        this.editable = true;

        this.currentRow = -1;

        this.fieldSelectionAllowed = true;

        this.initComponents();

    }

    private void initComponents() {

        ToolsSwingManager swingManager = ToolsSwingLocator.getToolsSwingManager();

        swingManager.translate(this.btnDelete);

        swingManager.translate(this.btnFormFieldAccept);

        swingManager.translate(this.btnFormFieldDiscard);

        swingManager.translate(this.btnFormFieldModify);

        swingManager.translate(this.btnNew);

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

        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.setPreferredSize(new Dimension(700, 400));

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

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

            doFormFieldPut();

        }

    }

    private boolean doFormFieldFetch() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return true;

        }

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

        if( descriptor instanceof EditableFeatureAttributeDescriptor ) {

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

                return false;

            }

            this.tableModel.fireUpdateEvent();

        } 

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

        } else {

            this.btnFormFieldModify.setEnabled(false);

        }

    }

    private void updateButtonState() {

        this.descriptorPanel.setEnabled(true);

        this.descriptorPanel.setEditable(false);

        this.btnFormFieldAccept.setEnabled(false);

        this.btnFormFieldDiscard.setEnabled(false);

        this.btnFormFieldModify.setEnabled(this.editable);

        this.btnNew.setEnabled(true);

        this.btnDelete.setEnabled(true);

    }

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

        this.btnFormFieldAccept.setEnabled(this.editable);

        this.btnFormFieldDiscard.setEnabled(this.editable);

        this.btnFormFieldModify.setEnabled(false);

        this.btnNew.setEnabled(false);

        this.btnDelete.setEnabled(false);

        if( descriptor instanceof EditableFeatureAttributeDescriptor ) {

            this.descriptorPanel.setEditable(this.editable);

        } else {

            this.descriptorPanel.setEditable(false);

        }

        this.fieldSelectionAllowed = false;

    }

    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;

        }

    }

    private void doFormFieldDiscard() {

        doFormFieldPut();

        this.updateButtonState();

        this.fieldSelectionAllowed = true;

    }

    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;

    }

    public void setEditable(boolean editable) {

        this.editable = editable;

        this.btnNew.setEnabled(editable);

        this.btnDelete.setEnabled(editable);

        updateButtonState();

    }

    @Override

    public EditableFeatureType fetch(EditableFeatureType type) {

        return type;

    }

    @Override

    public void put(FeatureType type) {

        this.featureType = type;

        if( type == null ) {

            this.store = null;

        } else {

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

            // el featureType se guarda solo una WeakReference.

            this.store = type.getStore(); 

        }

        if( !(type instanceof EditableFeatureType) ) {

            this.setEditable(false);

        }

        this.tableModel = new FeatureTypeTableModel(type);

        this.tblFields.setModel(this.tableModel);

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

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

        }

        updateButtonState();

        doFormFieldPut();       

    }

    private void doNewField() {

        EditableFeatureType eft = (EditableFeatureType)this.featureType;

        EditableFeatureAttributeDescriptor descriptor = eft.add(

                getNewFieldName(this.featureType), 

                DataTypes.STRING,

                50

        );

        this.tableModel.fireUpdateEvent();

        int row = descriptor.getIndex();

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

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

        updateButtonState();

        doFormFieldModify();       

    }

    private void doDeleteField() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

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

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

        this.tableModel.fireUpdateEvent();

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

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

        }

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

        updateButtonState();

        doFormFieldPut();       

    }

    public static String getNewFieldName(FeatureType featureType) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        String prefix = i18n.getTranslation("_Field");

        String fieldName;

        for (int i = 1; i < 1000; i++) {

            fieldName = prefix +"-"+i;

            if( featureType.get(fieldName)==null ) {

                return fieldName;

            }

        }

        fieldName = prefix + "-" + (new Date()).getTime();

        return fieldName;

    }

}