Application: gvSIG desktop

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

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.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.event.TableModelEvent;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.TableModel;

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;

/**

 *

 * @author jjdelcerro

 */

public class DefaultFeatureTypePanel

        extends FeatureTypePanelView

        implements FeatureTypePanel

    {

    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;

    public DefaultFeatureTypePanel() {

        this.editable = true;

        this.initComponents();

    }

    private void initComponents() {

        this.tableModel = new FeatureTypeTableModel();

        this.tblFields.setModel(this.tableModel);

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

            @Override

            public void valueChanged(ListSelectionEvent e) {

                doFormFieldPut();

            }

        });

        this.descriptorPanel = new DefaultFeatureTypeAttributePanel();

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

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

        this.descriptorPanel.setEnabled(false);

        this.btnFormFieldDiscard.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doFormFieldPut();

            }

        });

        this.btnFormFieldAccept.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doFormFieldFetch();

            }

        });

        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, 500));

    }

    private void doFormFieldFetch() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

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

        if( descriptor instanceof EditableFeatureAttributeDescriptor ) {

            this.descriptorPanel.fetch((EditableFeatureAttributeDescriptor) descriptor);

            this.tableModel.fireUpdateEvent();

        }

    }

    private void doFormFieldPut() {

        int row = this.tblFields.getSelectedRow();

        if( row<0 ) {

            return;

        }

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

        this.descriptorPanel.put(descriptor);

        this.descriptorPanel.setEnabled(true);

        if( descriptor instanceof EditableFeatureAttributeDescriptor ) {

            this.btnFormFieldAccept.setEnabled(this.editable);

            this.descriptorPanel.setEditable(this.editable);

        } else {

            this.btnFormFieldAccept.setEnabled(false);

            this.descriptorPanel.setEditable(false);

        }

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    public void setEditable(boolean editable) {

        this.editable = editable;

        this.btnFormFieldAccept.setEnabled(editable);

        this.btnFormFieldDiscard.setEnabled(editable);

        this.btnNew.setEnabled(editable);

        this.btnDelete.setEnabled(editable);

        this.descriptorPanel.setEnabled(editable);

    }

    @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 featureTyper 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.size()>0 ) {

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

        }

    }

    private void doNewField() {

        EditableFeatureType eft = (EditableFeatureType)this.featureType;

        EditableFeatureAttributeDescriptor descriptor = eft.add(

                this.getNewFieldName(),

                DataTypes.STRING

        );

        this.tableModel.fireUpdateEvent();

        int row = descriptor.getIndex();

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

    }

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

    }

    private String getNewFieldName() {

        I18nManager i18n = ToolsLocator.getI18nManager();

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

        String fieldName;

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

            fieldName = prefix +"-"+i;

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

                return fieldName;

            }

        }

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

        return fieldName;

    }

}