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.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.dynform.DynFormDefinition;

import org.gvsig.tools.dynform.DynFormFieldDefinition;

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

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.ServiceManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class SimpleTableJDynFormSet extends AbstractJDynFormSet {

    private static final Logger logger = LoggerFactory.getLogger(SimpleTableJDynFormSet.class);

        private JButton addButton;

        private JButton deleteButton;

        private JTable table;

        private DynObjectListTableModel tableModel;

        private int currentIndex;

    private int currentCol;

    public SimpleTableJDynFormSet(ServiceManager manager, DynFormDefinition definition) throws ServiceException {

        super(manager, definition);

    }

    @Override

    public void setValues(List values) throws ServiceException {

            super.setValues(values);

            this.tableModel.setValues(values);

            if(values == null){

                    addButton.setEnabled(false);

                    deleteButton.setEnabled(false);

            }else{

                    addButton.setEnabled(true);

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

            }

    }

    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;

    }

    public int getCurrentIndex() {

        return currentIndex;

    }

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

//                gbl_panel_chartType.rowHeights = new int[] { 0, 500, 0, 0, 0, 0, 0,

//                                0,0,0,0,175,10 };

                panel_chartType.setLayout(gbl_panel_chartType);

//                tablePanel = new JTable() {

//                        /**

//                         * 

//                         */

//                        private static final long serialVersionUID = -352323096347454258L;

//                        public boolean isCellEditable(int rowIndex, int colIndex) {

//                                if (colIndex == 0)

//                                        return true;

//                                return false; // Disallow the editing of any cell

//                        }

//                }

                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;

                //table.add(this.form.asJComponent());

                JScrollPane scrollPane = new JScrollPane(table);

                scrollPane.setPreferredSize(new Dimension(scrollPane.getWidth(),80));

                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(){

                public void valueChanged(ListSelectionEvent event) {

                    setCurrentIndex(table.getSelectedRow());

                    setCurrentCol(table.getSelectedColumn());

                }

            });

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

                table.setModel(tableModel);

    }

    public static class DynObjectListTableModel implements TableModel{

            private List<DynObject> values;

                private DynStruct definition;

                private 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>() {

                            public int compare(DynField o1, DynField o2) {

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

                            };

                        });

                    this.listeners = new ArrayList<TableModelListener>();

            }

                public void setValues(List objs) {

                        this.values = objs;

                        fireTableChangeEvent(-1, -1);

                }

                public void addTableModelListener(TableModelListener arg0) {

                        listeners.add(arg0);

                }

                public Class<?> getColumnClass(int arg0) {

                        DynField field = this.fields[arg0];

                        return field.getDataType().getDefaultClass();

                }

                public int getColumnCount() {

                        return this.fields.length;

                }

                public String getColumnName(int index) {

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

                }

                public int getRowCount() {

                        if(this.values == null){

                                return 0;

                        }

                        return this.values.size();

                }

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

                }

                public boolean isCellEditable(int arg0, int arg1) {

                        return true;

                }

                public void removeTableModelListener(TableModelListener arg0) {

                        this.listeners.remove(arg0);

                }

                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 = null;

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

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

                        TableColumn col = new TableColumn();

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

                        col.setHeaderValue(field.getLabel());

//                        col.setCellRenderer(getDefaultTableCellRenderer(field));

//                        col.setCellEditor(getDefaultTableCellEditor(field));

                        colModel.addColumn(col);

                }

                return colModel;

        }

        private SimpleTableCellEditor getDefaultTableCellEditor(DynFormFieldDefinition field) {

                return new SimpleTableCellEditor(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() {

                                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() {

                                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;

    }

    public boolean hasValidValues() {

        return true;

    }

    public boolean hasValidValues(List<String> fieldsName) {

        return true;

    }

    public List getValues() {

        TableCellEditor editor = this.table.getCellEditor();

        if( editor!=null ) {

            editor.stopCellEditing();

        }

        return this.values;

    }

}