Application: gvSIG desktop

package org.gvsig.export.swing.impl.panels;

import java.awt.Component;

import java.awt.Font;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import java.net.URL;

import java.util.ArrayList;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import java.util.Objects;

import javax.swing.DefaultCellEditor;

import javax.swing.DefaultComboBoxModel;

import javax.swing.DefaultListCellRenderer;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.TableCellRenderer;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

import javax.swing.text.JTextComponent;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang.StringUtils;

import org.gvsig.export.ExportAttributes;

import org.gvsig.export.ExportAttributes.ExportAttribute;

import org.gvsig.export.ExportParameters;

import org.gvsig.export.swing.JExportProcessPanel;

import org.gvsig.export.swing.spi.ExportPanel;

import org.gvsig.export.swing.spi.ExportPanelValidationException;

import org.gvsig.export.swing.spi.ExportPanelsManager;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataType;

import org.gvsig.tools.dataTypes.DataTypesManager;

import org.gvsig.tools.i18n.I18nManager;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class SelectAttributesPanel

        extends SelectAttributesPanelView

        implements ExportPanel {

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

    private static final int COLUMN_FIELD_EXPORT = 0;

    private static final int COLUMN_FIELD_TYPE = 1;

    private static final int COLUMN_FIELD_SIZE = 2;

    private static final int COLUMN_FIELD_ORIGIN = 3;

    private static final int COLUMN_FIELD_CALCULATED = 4;

    private static final int COLUMN_FIELD_NAME = 5;

    private static final int COLUMN_FIELD_NEW_NAME =6;

    private static final int COLUMN_FIELD_COUNT = 7;

    private static final int ORIGIN_REAL = 0;

    private static final int ORIGIN_CALCULATED = 1;

    private static final int ORIGIN_EXTRA = 2;

    private static class AttributesTableModel

            extends AbstractTableModel

            implements TableModel {

        final private ExportAttributes attributes;

        private final String[] columnNames = new String[COLUMN_FIELD_COUNT];

        private final Class[] columnClases = new Class[COLUMN_FIELD_COUNT];

        private final DataTypesManager dataManager;

        public AttributesTableModel(ExportAttributes attributes) {

            this.attributes = attributes;

            this.dataManager = ToolsLocator.getDataTypesManager();

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            columnNames[COLUMN_FIELD_NAME] = i18nManager.getTranslation("_name");

            columnNames[COLUMN_FIELD_NEW_NAME] = i18nManager.getTranslation("_New_name");

            columnNames[COLUMN_FIELD_ORIGIN] = i18nManager.getTranslation("_Origin");

            columnNames[COLUMN_FIELD_TYPE] = i18nManager.getTranslation("_type");

            columnNames[COLUMN_FIELD_SIZE] = i18nManager.getTranslation("_Size");

            columnNames[COLUMN_FIELD_CALCULATED] = i18nManager.getTranslation("_Virtual");

            columnNames[COLUMN_FIELD_EXPORT] = "";

            columnClases[COLUMN_FIELD_NAME] = String.class;

            columnClases[COLUMN_FIELD_NEW_NAME] = String.class;

            columnClases[COLUMN_FIELD_ORIGIN] = String.class;

            columnClases[COLUMN_FIELD_TYPE] = String.class;

            columnClases[COLUMN_FIELD_SIZE] = Integer.class;

            columnClases[COLUMN_FIELD_EXPORT] = Boolean.class;

            columnClases[COLUMN_FIELD_CALCULATED] = Boolean.class;

        }

        @Override

        public int getRowCount() {

            return this.attributes.size();

        }

        @Override

        public int getColumnCount() {

            return COLUMN_FIELD_COUNT;

        }

        @Override

        public String getColumnName(int columnIndex) {

            return this.columnNames[columnIndex];

        }

        @Override

        public Class<?> getColumnClass(int columnIndex) {

            return this.columnClases[columnIndex];

        }

        @Override

        public boolean isCellEditable(int rowIndex, int columnIndex) {

            switch (columnIndex) {

                case COLUMN_FIELD_NAME:

                    return false;

                case COLUMN_FIELD_ORIGIN:

                    return false;

                case COLUMN_FIELD_CALCULATED: {

                    ExportAttribute attr = this.attributes.get(rowIndex);

                    DataType dataType = attr.getDescriptor().getDataType();

                    if( dataType.isContainer() ||

                        dataType.isObject() ||

                        dataType.isDynObject() ) {

                        return false;

                    }

                    if (attr.getDescriptor().isComputed()) {

                        return true;

                    }

                    return false;

                }

                default:

                    return true;

            }

        }

        @Override

        public Object getValueAt(int rowIndex, int columnIndex) {

            ExportAttribute attr = this.attributes.get(rowIndex);

            switch (columnIndex) {

                case COLUMN_FIELD_NAME:

                    return attr.getName();

                case COLUMN_FIELD_NEW_NAME:

                    return attr.getNewName();

                case COLUMN_FIELD_ORIGIN:

                    if (attr.getDescriptor().isComputed()) {

                       if (attr.getDescriptor().getFeatureType()!=null) {

                           return ORIGIN_CALCULATED;

                       } else {

                           return ORIGIN_EXTRA;

                       }

                    } else {

                        return ORIGIN_REAL;

                    }

                case COLUMN_FIELD_TYPE:

                    return dataManager.getTypeName(attr.getNewDataType());

                case COLUMN_FIELD_SIZE:

                    return attr.getSize();

                case COLUMN_FIELD_EXPORT:

                    return attr.isExported();

                case COLUMN_FIELD_CALCULATED:

                    return attr.isComputed();

                default:

                    return null;

            }

        }

        @Override

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

            ExportAttribute attr = this.attributes.get(rowIndex);

            switch (columnIndex) {

                case COLUMN_FIELD_NAME:

                    break;

                case COLUMN_FIELD_NEW_NAME:

                    attr.setNewName(Objects.toString(aValue, attr.getName()));

                    break;

                case COLUMN_FIELD_TYPE:

                    attr.setNewType(dataManager.getType(Objects.toString(aValue)));

                    break;

                case COLUMN_FIELD_SIZE:

                    try {

                        attr.setSize(Integer.parseInt(Objects.toString(aValue)));

                    } catch (Exception ex) {

                        LOGGER.warn("Not been able to set size value of attribute " + attr.getName() + " (" + Objects.toString(aValue) + ").", ex);

                    }

                    break;

                case COLUMN_FIELD_EXPORT:

                    try {

                        attr.setExported((boolean) dataManager.get(DataTypes.BOOLEAN).coerce(aValue));

                    } catch (Exception ex) {

                        LOGGER.warn("Not been able to set exported value of attribute " + attr.getName() + " (" + Objects.toString(aValue) + ").", ex);

                    }

                    break;

                case COLUMN_FIELD_CALCULATED:

                    try {

                        attr.setComputed((boolean) dataManager.get(DataTypes.BOOLEAN).coerce(aValue));

                    } catch (Exception ex) {

                        LOGGER.warn("Not been able to set calculated value of attribute " + attr.getName() + " (" + Objects.toString(aValue) + ").", ex);

                    }

                    break;

                default:

                    break;

            }

            this.fireTableCellUpdated(rowIndex, columnIndex);

        }

    }

    private static class TableFilterController {

        private final JTable jtable;

        private final JTextComponent jtext;

        private final JButton btnFilter;

        private final int filterColumn;

        private FilteredTableModel tableModel;

        public TableFilterController(JTable jtable, JTextComponent jtext, JButton btnFilter, int filterColumn) {

            this.jtable = jtable;

            this.filterColumn = filterColumn;

            this.btnFilter = btnFilter;

            this.jtext = jtext;

            this.tableModel = null;

            ToolsSwingLocator.getToolsSwingManager().setDefaultPopupMenu(jtext);

            ToolsSwingLocator.getToolsSwingManager().addClearButton(jtext, new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    if (tableModel != null) {

                        tableModel.setFilter(null);

                        jtext.setText("");

                    }

                }

            });

            this.jtext.addKeyListener(new KeyAdapter() {

                @Override

                public void keyPressed(KeyEvent e) {

                    if (e.getKeyChar() == '\n') {

                        if (tableModel != null) {

                            tableModel.setFilter(jtext.getText());

                        }

                    }

                }

            });

            this.btnFilter.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent e) {

                    if (tableModel != null) {

                        tableModel.setFilter(jtext.getText());

                    }

                }

            });

        }

        public void setModel(TableModel tableModel) {

            this.tableModel = ToolsSwingLocator.getToolsSwingManager().createFilteredTableModel(

                    tableModel,

                    this.filterColumn

            );

            this.jtable.setModel(this.tableModel);

        }

    }

    private class DataTypeCellRenderer

            extends JLabel

            implements TableCellRenderer {

        public DataTypeCellRenderer() {

        }

        @Override

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

            if (value != null) {

                String name = (String) table.getModel().getValueAt(row, COLUMN_FIELD_NAME);

                this.setText(value.toString());

                Font f = this.getFont();

                if (isOriginalType(row, value.toString())) {

                    this.setFont(f.deriveFont(f.getStyle() & ~Font.BOLD));

                } else {

                    this.setFont(f.deriveFont(f.getStyle() | Font.BOLD));

                }

            } else {

                this.setText("");

            }

            return this;

        }

    }

    private class OriginCellRenderer

            extends JLabel

            implements TableCellRenderer {

        public OriginCellRenderer() {

        }

        @Override

        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {

            if (column == COLUMN_FIELD_ORIGIN) {

                int origin = (int) table.getModel().getValueAt(row, COLUMN_FIELD_ORIGIN);

                IconTheme iconManager = ToolsSwingLocator.getIconThemeManager().getDefault();

                I18nManager i18Manager = ToolsLocator.getI18nManager();

                this.setHorizontalAlignment(JLabel.CENTER);

                switch (origin) {

                    case ORIGIN_CALCULATED:

                        this.setToolTipText(i18Manager.getTranslation("_Calculated_field"));

                        this.setIcon((iconManager.get("column-calculated")));

                        break;

                    case ORIGIN_EXTRA:

                        this.setToolTipText(i18Manager.getTranslation("_Extra_field"));

                        this.setIcon((iconManager.get("column-extra")));

                        break;

                    case ORIGIN_REAL:

                        this.setToolTipText(i18Manager.getTranslation("_Real_field"));

                        this.setIcon((iconManager.get("column-true")));

                        break;

                    default:

                        this.setText(value.toString());

                        break;

                }

                return this;

            }

            return this;

        }

    }

    private class DataTypeCellEditor extends DefaultCellEditor {

        private int currentRow = -1;

        private class DataTypeListCellRenderer extends DefaultListCellRenderer {

            @Override

            public Component getListCellRendererComponent(JList<?> list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

                JLabel label = (JLabel) super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

                if (value != null) {

                    label.setText(value.toString());

                    Font f = label.getFont();

                    if (isOriginalType(currentRow, value.toString())) {

                        label.setFont(f.deriveFont(f.getStyle() | Font.BOLD));

                    } else {

                        label.setFont(f.deriveFont(f.getStyle() & ~Font.BOLD));

                    }

                }

                return label;

            }

        }

        public DataTypeCellEditor() {

            super(new JComboBox());

            JComboBox combo = (JComboBox) this.getComponent();

            combo.setRenderer(new DataTypeListCellRenderer());

            combo.setModel(this.getDataTypeComboModel());

        }

        @Override

        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {

            this.currentRow = row;

            JComboBox combo = (JComboBox) super.getTableCellEditorComponent(table, value, isSelected, row, column);

            ListElement.setSelected(combo, value);

            return combo;

        }

        private DefaultComboBoxModel getDataTypeComboModel() {

            DataTypesManager dataManager = ToolsLocator.getDataTypesManager();

            List<ListElement<Integer>> fieldTypes = new ArrayList<>();

            Iterator<DataType> it = dataManager.iterator();

            while (it.hasNext()) {

                DataType dataType = it.next();

                fieldTypes.add( new ListElement<>(dataType.getName(), dataType.getType()) );

            }

            fieldTypes.sort(new Comparator<ListElement<Integer>>() {

                @Override

                public int compare(ListElement<Integer> o1, ListElement<Integer> o2) {

                    return o1.toString().compareTo(o2.toString());

                }

            });

            DefaultComboBoxModel<ListElement<Integer>> model = new DefaultComboBoxModel<>();

            for (ListElement<Integer> element : fieldTypes) {

                model.addElement(element);

            }

            return model;

        }

    }

    private final ExportParameters parameters;

    private final JExportProcessPanel processPanel;

//    private Map<String, String> fieldAttributeTypes;

//    private FilteredTableModel filteredTableModel;

    private TableModel tableModel;

    private TableFilterController tableFilterController;

    private FeatureType targetFeatureType ;

    public SelectAttributesPanel(

            JExportProcessPanel processPanel,

            ExportParameters parameters

    ) {

        this.processPanel = processPanel;

        this.parameters = parameters;

        this.parameters.getExportAttributes().setActive(true);

        this.initComponents();

    }

    @Override

    public String getIdPanel() {

        return ExportPanelsManager.PANEL_ATTRIBUTES_SELECTION;

    }

    @Override

    public String getTitlePanel() {

        I18nManager i18n = ToolsLocator.getI18nManager();

        return i18n.getTranslation("_Attribute_Selection");

    }

    @Override

    public boolean validatePanel() throws ExportPanelValidationException {

        ExportAttributes expAttrs = this.parameters.getExportAttributes();

        if (!expAttrs.isAttributeNamesValid()) {

            I18nManager i18nManager = ToolsLocator.getI18nManager();

            int as = JOptionPane.showConfirmDialog(

                    this,

                    i18nManager.getTranslation("_Not_valid_attribute_names_Do_you_want_a_suggest_names?"),

                    i18nManager.getTranslation("_Not_valid_attriute_names"),

                    JOptionPane.YES_NO_OPTION

            );

            if (as == JOptionPane.YES_OPTION) {

                expAttrs.fixAttributeNames();

                this.fillTableWithAttributes();

            } else if (as == JOptionPane.NO_OPTION) {

            }

            return false;

        }

        return true;

    }

    @Override

    public void enterPanel() {

        this.fillTableWithAttributes();

    }

    @Override

    public void previousPanel() {

        this.fillTableWithAttributes();

    }

    @Override

    public void nextPanel() {

        //get params are in the validate method

    }

    @Override

    public JComponent asJComponent() {

        return this;

    }

    private boolean isOriginalType(int row, String type) {

        try {

            if( this.targetFeatureType==null ) {

                return true;

            }

            TableModel model = this.tblAttributes.getModel();

            String name = (String) model.getValueAt(row, COLUMN_FIELD_NAME);

            FeatureAttributeDescriptor attr = this.targetFeatureType.getAttributeDescriptor(name);

            if (attr == null) {

                return true;

            }

            return StringUtils.equalsIgnoreCase(type, attr.getDataTypeName());

        } catch (Exception ex) {

            return true;

        }

    }

    private ExportAttributes getExportAttributes() {

        ExportAttributes attributes = this.parameters.getExportAttributes();

        return attributes;

    }

    private void fillTableWithAttributes() {

        ExportAttributes attributes = this.getExportAttributes();

        if( this.targetFeatureType == null ) {

            this.targetFeatureType = this.getExportAttributes().getTargetFeatureType();

        }

        this.tableModel = new AttributesTableModel(attributes);

        this.tblAttributes.setModel(this.tableModel);

        this.tableFilterController.setModel(this.tableModel);

        TableColumnModel columnModel = this.tblAttributes.getColumnModel();

        columnModel.getColumn(COLUMN_FIELD_ORIGIN).setCellRenderer(new OriginCellRenderer());

        columnModel.getColumn(COLUMN_FIELD_TYPE).setCellEditor(new DataTypeCellEditor());

        columnModel.getColumn(COLUMN_FIELD_TYPE).setCellRenderer(new DataTypeCellRenderer());

        columnModel.getColumn(COLUMN_FIELD_EXPORT).setPreferredWidth( new JCheckBox().getPreferredSize().width*2);

        columnModel.getColumn(COLUMN_FIELD_TYPE).setPreferredWidth( new JLabel("XIntegerX").getPreferredSize().width);

        columnModel.getColumn(COLUMN_FIELD_SIZE).setPreferredWidth( new JLabel("00000").getPreferredSize().width);

        columnModel.getColumn(COLUMN_FIELD_ORIGIN).setPreferredWidth( new JLabel("000").getPreferredSize().width);

        columnModel.getColumn(COLUMN_FIELD_CALCULATED).setPreferredWidth( new JLabel("000").getPreferredSize().width);

    }

    private void initComponents() {

        this.tblAttributes.setAutoCreateRowSorter(true);

        this.tblAttributes.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);

        this.tableFilterController = new TableFilterController(

                this.tblAttributes,

                this.txtFilter,

                this.btnFilter,

                COLUMN_FIELD_NAME

        );

        this.btnCheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doCheckAll();

            }

        });

        this.btnUncheckAll.addActionListener(new ActionListener() {

            @Override

            public void actionPerformed(ActionEvent e) {

                doUncheckAll();

            }

        });

        this.translate();

    }

    private void doUncheckAll() {

        TableModel model = this.tblAttributes.getModel();

        for (int row = 0; row < model.getRowCount(); row++) {

            model.setValueAt(false, row, COLUMN_FIELD_EXPORT);

        }

    }

    private void doCheckAll() {

        TableModel model = this.tblAttributes.getModel();

        for (int row = 0; row < model.getRowCount(); row++) {

            model.setValueAt(true, row, COLUMN_FIELD_EXPORT);

        }

    }

    private void translate() {

        ToolsSwingManager manager = ToolsSwingLocator.getToolsSwingManager();

        manager.translate(this.lblHeader);

    }

    @Override

    public ImageIcon loadImage(String imageName) {

        String name = FilenameUtils.getBaseName(imageName);

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

        if (theme.exists(name)) {

            return theme.get(name);

        }

        URL url = this.getClass().getResource(name + ".png");

        if (url == null) {

            return null;

        }

        return new ImageIcon(url);

    }

}