Application: gvSIG desktop » Library: org.gvsig.tools

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.tools.dynform.services.dynformset.simpletable;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.Insets;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.net.URL;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import javax.swing.Action;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.ListSelectionModel;

import javax.swing.event.ListSelectionEvent;

import javax.swing.event.ListSelectionListener;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.DefaultTableColumnModel;

import javax.swing.table.TableCellEditor;

import javax.swing.table.TableColumn;

import javax.swing.table.TableColumnModel;

import javax.swing.table.TableModel;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

import org.gvsig.tools.dynform.JDynForm.DynFormContext;

import org.gvsig.tools.dynform.spi.dynformset.AbstractJDynFormSet;

import org.gvsig.tools.dynform.spi.DynFormSPIManager;

import org.gvsig.tools.dynform.spi.dynformset.JDynFormSetFactory;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.Tags;

import org.gvsig.tools.service.ServiceException;

public class SimpleTableJDynFormSet extends AbstractJDynFormSet {

    private JButton addButton;

    private JButton deleteButton;

    private JTable table;

    private DynObjectListTableModel tableModel;

    private int currentIndex;

    private int currentCol;

    public SimpleTableJDynFormSet(

            DynFormSPIManager manager,

            JDynFormSetFactory factory,

            DynFormContext context,

            DynFormDefinition definition,

            Tags contextTags

    ) {

        super(manager, factory, context, definition, contextTags);

        this.formHeight = 80;

    }

    @Override

    public void setValues(List values) {

        super.setValues(values);

        this.tableModel.setValues(values);

        if (values == null) {

            addButton.setEnabled(false);

            deleteButton.setEnabled(false);

        } else {

            addButton.setEnabled(true);

            deleteButton.setEnabled(!values.isEmpty());

        }

    }

    @Override

    public JComponent asJComponent() {

        if (this.contents == null) {

            try {

                this.initComponents();

            } catch (ServiceException e) {

                throw new RuntimeException(e.getLocalizedMessage(), e);

            }

        }

        this.fireFormMovedToEvent(0);

        return this.contents;

    }

    @Override

    public int getCurrentIndex() {

        return currentIndex;

    }

    @Override

    public void setCurrentIndex(int index) {

        if (index < tableModel.getRowCount()) {

            this.currentIndex = index;

        }

    }

    private void initComponents() throws ServiceException {

        this.contents = getTablePanel();

    }

    private JPanel getTablePanel() {

        JPanel panel_chartType = new JPanel();

        GridBagLayout gbl_panel_chartType = new GridBagLayout();

        panel_chartType.setLayout(gbl_panel_chartType);

        createJTable();

        GridBagConstraints gbc_table = new GridBagConstraints();

        gbc_table.gridheight = 3;

        gbc_table.gridwidth = 2;

        gbc_table.insets = new Insets(0, 0, 0, 5);

        gbc_table.fill = GridBagConstraints.BOTH;

        gbc_table.weightx = 1.0;

        gbc_table.weighty = 0.0;

        gbc_table.gridx = 0;

        gbc_table.gridy = 0;

        JScrollPane scrollPane = new JScrollPane(table);

        scrollPane.setPreferredSize(new Dimension(scrollPane.getWidth(), this.formHeight));

        panel_chartType.add(scrollPane, gbc_table);

        GridBagConstraints gbc_addButton = new GridBagConstraints();

        gbc_addButton.anchor = GridBagConstraints.EAST;

        gbc_addButton.insets = new Insets(0, 0, 5, 0);

        gbc_addButton.gridx = 2;

        gbc_addButton.gridy = 0;

        panel_chartType.add(getAddButton(), gbc_addButton);

        GridBagConstraints gbc_deleteButton = new GridBagConstraints();

        gbc_deleteButton.anchor = GridBagConstraints.NORTHEAST;

        gbc_deleteButton.gridx = 2;

        gbc_deleteButton.gridy = 2;

        panel_chartType.add(getDeleteButton(), gbc_deleteButton);

        return panel_chartType;

    }

    private void createJTable() {

        table = new JTable();

        table.setBackground(Color.white);

        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);

        table.setColumnModel(getColumnModel());

        table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {

            @Override

            public void valueChanged(ListSelectionEvent event) {

                setCurrentIndex(table.getSelectedRow());

                setCurrentCol(table.getSelectedColumn());

            }

        });

        this.tableModel = new DynObjectListTableModel(this.values, this.getDefinition().getElementsType());

        table.setModel(tableModel);

    }

    @Override

    public void addAction(Action action) {

        LOGGER.info("AddAction not implemented over SimpleTableJDynFormSet.");

    }

    @Override

    public void setActionEnabled(String action, boolean enabled) {

        LOGGER.info("setActionEnabled not implemented over SimpleTableJDynFormSet.");

    }

    @Override

    public void setActionVisible(String action, boolean visible) {

        LOGGER.info("setActionVisible not implemented over SimpleTableJDynFormSet.");

    }

    @Override

    public boolean isActionEnabled(String action) {

        LOGGER.info("isActionEnabled not implemented over SimpleTableJDynFormSet.");

        return true;

    }

    @Override

    public boolean isActionVisible(String action) {

        LOGGER.info("isActionVisible not implemented over SimpleTableJDynFormSet.");

        return true;

    }

    @Override

    public JComponent getActionButton(String action) {

        return null;

    }

    public static class DynObjectListTableModel implements TableModel {

        private List<DynObject> values;

        private DynStruct definition;

        private final List<TableModelListener> listeners;

        private DynField[] fields;

        public DynObjectListTableModel(List<DynObject> objs, DynStruct struct) {

            this.values = objs;

            this.definition = struct;

            fields = this.definition.getDynFields();

            Arrays.sort(fields, new Comparator<DynField>() {

                @Override

                public int compare(DynField o1, DynField o2) {

                    return o1.getOder() - o2.getOder();

                }

            ;

            });

            this.listeners = new ArrayList<>();

        }

        public void setValues(List objs) {

            this.values = objs;

            fireTableChangeEvent(-1, -1);

        }

        @Override

        public void addTableModelListener(TableModelListener arg0) {

            listeners.add(arg0);

        }

        @Override

        public Class<?> getColumnClass(int arg0) {

            DynField field = this.fields[arg0];

            return field.getDataType().getDefaultClass();

        }

        @Override

        public int getColumnCount() {

            return this.fields.length;

        }

        @Override

        public String getColumnName(int index) {

            return this.fields[index].getName();

        }

        @Override

        public int getRowCount() {

            if (this.values == null) {

                return 0;

            }

            return this.values.size();

        }

        @Override

        public Object getValueAt(int row, int col) {

            if (this.values == null) {

                return null;

            }

            DynObject value = this.values.get(row);

            String colName = this.getColumnName(col);

            return value.getDynValue(colName);

        }

        @Override

        public boolean isCellEditable(int arg0, int arg1) {

            return true;

        }

        @Override

        public void removeTableModelListener(TableModelListener arg0) {

            this.listeners.remove(arg0);

        }

        @Override

        public void setValueAt(Object arg0, int row, int col) {

            if (this.values == null) {

                return;

            }

            DynObject value = this.values.get(row);

            String colName = this.getColumnName(col);

            value.setDynValue(colName, arg0);

            fireTableChangeEvent(row, TableModelEvent.UPDATE);

        }

        public void addNew() {

            if (this.values == null) {

                return;

            }

            DynObject dynobj = ToolsLocator.getDynObjectManager().createDynObject(this.definition);

            this.values.add(dynobj);

            fireTableChangeEvent(this.values.size(), TableModelEvent.INSERT);

        }

        public void remove(int index) {

            if (this.values == null) {

                return;

            }

            this.values.remove(index);

            fireTableChangeEvent(index, TableModelEvent.DELETE);

        }

        private void fireTableChangeEvent(int row, int type) {

            Iterator<TableModelListener> it = this.listeners.iterator();

            while (it.hasNext()) {

                TableModelListener listener = (TableModelListener) it.next();

                TableModelEvent ev;

                if (row < 0) {

                    ev = new TableModelEvent(this);

                } else {

                    ev = new TableModelEvent(this, row, row, TableModelEvent.ALL_COLUMNS, type);

                }

                listener.tableChanged(ev);

            }

        }

    }

    private TableColumnModel getColumnModel() {

        TableColumnModel colModel = new DefaultTableColumnModel();

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

        for (int i = 0; i < this.getDefinition().size(); i++) {

            TableColumn col = new TableColumn();

            DynFormFieldDefinition field = this.getDefinition().get(i);

            if (field.getTags().has(DynFormSPIManager.TAG_DYNFORM_WIDTH)) {

                try {

                    int width = field.getTags().getInt(DynFormSPIManager.TAG_DYNFORM_WIDTH);

                    col.setMaxWidth(width);

                } catch (CoercionException ex) {

                    // Do nothing

                }

            }

            col.setHeaderValue(field.getLabel());

            colModel.addColumn(col);

        }

        return colModel;

    }

    private SimpleTableCellEditor getDefaultTableCellEditor(DynFormFieldDefinition field) {

        return new SimpleTableCellEditor(this.getContext(), field, this.getServiceManager());

    }

    private SimpleTableCellRenderer getDefaultTableCellRenderer(DynFormFieldDefinition field) {

        return new SimpleTableCellRenderer(field);

    }

    private JButton getAddButton() {

        if (addButton == null) {

            addButton = new JButton("");

            addButton.setIcon(getIcon("dynform-table-add.png"));

            addButton.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent arg0) {

                    tableModel.addNew();

                    deleteButton.setEnabled(true);

                }

            });

            if (this.values == null) {

                addButton.setEnabled(false);

            }

        }

        return addButton;

    }

    private Icon getIcon(String fielName) {

        URL url = this.getClass().getClassLoader().getResource("org/gvsig/tools/dynform/services/" + fielName);

        return new ImageIcon(url);

    }

    private JButton getDeleteButton() {

        if (deleteButton == null) {

            deleteButton = new JButton("");

            deleteButton.setIcon(getIcon("dynform-table-delete.png"));

            deleteButton.setEnabled(false);

            deleteButton.addActionListener(new ActionListener() {

                @Override

                public void actionPerformed(ActionEvent arg0) {

                    int index = table.getSelectedRow();

                    if (index >= 0) {

                        tableModel.remove(index);

                        if (table.getRowCount() == 0) {

                            deleteButton.setEnabled(false);

                        }

                    }

                }

            });

        }

        return deleteButton;

    }

    @Override

    public void setReadOnly(boolean readOnly) {

        super.setReadOnly(readOnly);

        this.table.setEnabled(!readOnly);

        this.getAddButton().setEnabled(!readOnly);

        this.getDeleteButton().setEnabled(!readOnly);

    }

    void setCurrentCol(int col) {

        this.currentCol = col;

    }

    @Override

    public boolean hasValidValues() {

        return true;

    }

    @Override

    public boolean hasValidValues(List<String> fieldsName) {

        return true;

    }

    @Override

    public List getValues() {

        TableCellEditor editor = this.table.getCellEditor();

        if (editor != null) {

            editor.stopCellEditing();

        }

        return this.values;

    }

}