Application: gvSIG desktop » gvSIG raster

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2012 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 2

 * 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.raster.swing.impl.pagedtable;

import java.awt.BorderLayout;

import java.awt.FlowLayout;

import java.awt.GridBagConstraints;

import java.awt.GridBagLayout;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.util.List;

import java.util.Observable;

import java.util.Observer;

import javax.swing.JPanel;

import javax.swing.JTable;

import javax.swing.event.TableModelEvent;

import javax.swing.event.TableModelListener;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableColumn;

import org.gvsig.raster.swing.pagedtable.ModelLoader;

import org.gvsig.raster.swing.pagedtable.PagedTableEvent;

/**

 * Paged table

 * 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class PagedTablePanel extends JPanel implements MouseListener, Observer, TableModelListener {

        private static final long          serialVersionUID       = 1L;

        private PagedJTable                jTable                 = null;

        private ModelLoader                modelLoader            = null;

        private DefaultTableModel          model                  = null;

        private Pager                      pager                  = null;

        private int                        heightLine             = 16;

        public class PagedJTable extends JTable {

                private static final long serialVersionUID = 1L;

                public PagedJTable(DefaultTableModel model, String[] columnNames) {

                        super(null, columnNames);

                        this.setModel(model);

                }

                /**

                 * Reimplemented to calculate the number of pages when the component gets

                 * a resize event

                 */

                public void setBounds(int x, int y, int width, int height) {

                super.setBounds(x, y, width, height);

                int entriesPerPage = (int)(getHeight() / (double)heightLine);

                        getPager(entriesPerPage);

            }

        }

        public PagedTablePanel(ModelLoader modelLoader,

                        Pager pager, 

                        PaginationBarPanel paginationBar,

                        MoveRowsPanel moveRowsPanel, 

                        TableEntryControllerPanel tableEntryControllerPanel) {

                this.modelLoader = modelLoader;

                this.pager = pager;

                this.model = (DefaultTableModel)modelLoader.getTableModel();

                initGUI(paginationBar, moveRowsPanel, tableEntryControllerPanel);

        }

        private void initGUI(

                        PaginationBarPanel paginationBar, 

                        MoveRowsPanel moveRowsPanel, 

                        TableEntryControllerPanel tableEntryControllerPanel) {

                setLayout(new GridBagLayout());

                GridBagConstraints gbc = new GridBagConstraints();

                gbc.fill = GridBagConstraints.BOTH;

                gbc.weightx = 1;

                gbc.weighty = 1;

                gbc.gridx = 0;

                gbc.gridy = 0;

                add(getJTableWithHeader(), gbc);

                gbc.fill = GridBagConstraints.VERTICAL;

                gbc.weightx = 0;

                gbc.weighty = 1;

                gbc.gridx = 1;

                gbc.gridy = 0;

                add(paginationBar, gbc);

                gbc.fill = GridBagConstraints.HORIZONTAL;

                gbc.weightx = 1;

                gbc.weighty = 0;

                gbc.gridx = 0;

                gbc.gridy = 1;

                gbc.gridwidth = 2;

                JPanel panel = new JPanel();

                panel.setLayout(new FlowLayout(FlowLayout.CENTER, 0, 0));

                panel.add(tableEntryControllerPanel);

                panel.add(moveRowsPanel);

                add(panel, gbc);

        }

        public Pager getPager(int nEntriesPerPage) {

                pager.setEntriesPerPage(nEntriesPerPage);

                return pager;

        }

        /**

         * Gets a panel with the JTable and its header

         * @return

         */

        public JPanel getJTableWithHeader() {

                JPanel p = new JPanel(new BorderLayout());

                JTableHeader header = getJTable().getTableHeader();

                p.add(header, BorderLayout.NORTH);

                p.add(getJTable(), BorderLayout.CENTER);

                return p;

        }

        /**

         * Gets the JTable

         * @return Tabla de bandas de la imagen

         */

        public JTable getJTable() {

                if (jTable == null) {

                        jTable = new PagedJTable(model, modelLoader.getColumnNames());

                        jTable.addMouseListener(this);

                        jTable.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);

                        model.addTableModelListener(this);

                        TableColumn column = null;

                        int widthPerColumn = (int) (this.getWidth() / modelLoader.getColumnNames().length);

                        for (int i = 0; i < modelLoader.getColumnNames().length; i++) {

                                column = jTable.getColumnModel().getColumn(i);

                                column.setResizable(true);

                                if (modelLoader.getColumnWidths() == null)

                                        column.setPreferredWidth(widthPerColumn);

                                else {

                                        if(i < modelLoader.getColumnWidths().length && 

                                           modelLoader.getColumnWidths()[i] > 0) {

                                                column.setMaxWidth(modelLoader.getColumnWidths()[i]);

                                        } else {

                                                if(modelLoader.getColumnWidths()[i] == 0) {

                                                        column.setMinWidth(0);

                                                        column.setMaxWidth(0);

                                                } else

                                                        column.setPreferredWidth(widthPerColumn);

                                        }

                                }

                                if(modelLoader.getCellEditorForColumn(i) != null)

                                        column.setCellEditor(modelLoader.getCellEditorForColumn(i));

                                if(modelLoader.getRenderForColumn(i) != null)

                                        column.setCellRenderer(modelLoader.getRenderForColumn(i));

                        }

                }

                return jTable;

        } 

        public void tableChanged(TableModelEvent e) {

                if(e.getType() == TableModelEvent.UPDATE) {

                        int column = e.getColumn();

                        if(column != TableModelEvent.ALL_COLUMNS) {

                                Object[] entry = pager.getEntry(e.getFirstRow());

                                if(entry != null && column >= 0 && column < entry.length)

                                        entry[column] = model.getValueAt(e.getFirstRow(), column);

                                pager.throwEvent(PagedTableEvent.EVENT_MODIFY_ENTRY, new int[]{e.getFirstRow()});

                        }

                }

        }

        public void setLineHeight(int height) {

                this.heightLine = height;

        }

        /**

         * Gets the number of rows in this table

         * @return N?mero de filas de la tabla

         */

        public int getRowTableCount() {

                return model.getRowCount();

        }

        /**

         * Gets the selected point

         * @return position of the selected point

         */

        public int getSelectedTableRow() {

                return getJTable().getSelectedRow();

        }

        /**

         * Reloads the selected page in the visual table

         */

        private int reloadPage() {

                model.setNumRows(0);

                List<Object> lines = pager.getSelectedPage();

                if(lines == null)

                        return pager.getSelectedPageNumber();

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

                        model.addRow((Object[])lines.get(i));

                }

                return pager.getSelectedPageNumber();

        }

        public void mouseClicked(MouseEvent e) {

                if(e.getSource() == jTable) {

                        //When the user clicks on table, it selects the entry in the table control

                        int selVisualRow = getSelectedTableRow();

                        if(selVisualRow >= 0) {

                                int selRow = pager.getSelectedPageNumber() * pager.getEntriesPerPage() + selVisualRow;

                                pager.setSelectedRows(new int[]{selRow});

                        }

                }

        }

        public void mouseEntered(MouseEvent e) {

        }

        public void mouseExited(MouseEvent e) {

        }

        public void mousePressed(MouseEvent e) {

        }

        public void mouseReleased(MouseEvent e) {

        }

        public void update(Observable o, Object arg) {

                if(o instanceof Pager && arg instanceof Integer) {

                        int option = ((Integer)arg).intValue();

                        if(option == PagedTableEvent.EVENT_SELECTED_ROWS ) {

                                Pager pager = (Pager)o;

                                int[] selectedRows = pager.getSelectedRows();

                                if(selectedRows != null && selectedRows.length > 0) {

                                        if(!pager.isInCurrentPage(selectedRows[0])) {

                                                pager.setSelectedPage(pager.getPageFromRow(selectedRows[0]));

                                                reloadPage();

                                        }

                                        int r = selectedRows[0] % pager.getEntriesPerPage();

                                        if(r >= 0 && r < model.getRowCount())

                                                getJTable().setRowSelectionInterval(r, r);

                                }

                        }

                        if(option == PagedTableEvent.EVENT_ADD_ENTRY ) {

                                model.addRow(pager.getLastEntry());

                                int lastTableRow = model.getRowCount() - 1;

                                getJTable().setRowSelectionInterval(lastTableRow, lastTableRow);

                        }

                        if(option == PagedTableEvent.EVENT_REMOVE_ENTRY ) {

                                int[] selectedRows = pager.getSelectedRows();

                                reloadPage();

                                if(selectedRows != null) {

                                        int r = selectedRows[0] % pager.getEntriesPerPage();

                                        if(r >= 0 && r < model.getRowCount()) {

                                                getJTable().setRowSelectionInterval(r, r);

                                        }

                                }

                        }

                        if(option == PagedTableEvent.EVENT_REMOVE_ALL ) {

                                model.setNumRows(0);

                        }

                        if(option == PagedTableEvent.EVENT_SELECTED_PAGE || option == PagedTableEvent.EVENT_MODIFY_ENTRY) {

                                reloadPage();

                                int[] selectedRows = pager.getSelectedRows();

                                if(selectedRows != null) {

                                        int r = selectedRows[0] % pager.getEntriesPerPage();

                                        if(r >= 0 && r < model.getRowCount()) {

                                                getJTable().setRowSelectionInterval(r, r);

                                        }

                                }

                        }

                }

        }

}