source: trunk/gli/src/org/greenstone/gatherer/gui/metaaudit/MetaAuditTable.java@ 8313

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.gui.metaaudit;

import de.qfs.lib.gui.*;
import java.awt.*;
import java.util.ArrayList;
import javax.swing.JTable;
import javax.swing.event.TableModelEvent;
import javax.swing.table.*;
import org.greenstone.gatherer.file.FileNode;
import org.greenstone.gatherer.metadata.MetadataAuditTableModel;


/**
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 */
public class MetaAuditTable
    extends JTable 
    implements TableModelSorterListener {

    private boolean initial_state;

    private boolean ready;

    private Filter filter;

    private HeaderRenderer header_renderer;

    private MetaAuditFrame parent_frame;

    private MetadataAuditTableModel metadata_audit_table_model;

    private SortedTableHelper helper;

    static final private int MARGIN = 10;

    public MetaAuditTable(MetaAuditFrame parent_frame) {
    super();
    this.header_renderer = new HeaderRenderer();
    this.parent_frame = parent_frame;
    getTableHeader().addMouseListener(new HeaderListener(parent_frame, this));
    setAutoResizeMode(AUTO_RESIZE_OFF);
    setDefaultRenderer(ArrayList.class, new MetaAuditRenderer());
    ready = true;
    }

    public Filter getFilter() {
    return filter;
    }


   public MetadataAuditTableModel getOriginalModel()
   {
      return metadata_audit_table_model;
   }


    public TableModelSorter getSorter() {
    return helper.getTableModelSorter();
    }

    public boolean isFiltered(int column) {
    if(filter == null) {
        return false;
    }
    return filter.isFiltered(column);
    }

    public void newModel(FileNode records[]) {
    if(records == null || records.length == 0) {
        setModel(new DefaultTableModel());
        return;
    }
    wait(true);
    initial_state = true;
    // System.err.println("Build new Model - should only be called once per click!");
    metadata_audit_table_model = new MetadataAuditTableModel();
    metadata_audit_table_model.rebuild(records);
    setModel(metadata_audit_table_model);
    filter = new Filter(metadata_audit_table_model.getColumnCount());
    helper = new SortedTableHelper (this, filter, new DefaultTableModelSorter(), header_renderer, null);
    helper.prepareTable();
    // Add renderer to columns.
    TableColumnModel column_model = getColumnModel();
    for(int i = 0; i < column_model.getColumnCount(); i++) {
        column_model.getColumn(i).setHeaderRenderer(header_renderer);
    }
    wait(false);
    initial_state = false;
    }

    public void tableChanged(TableModelEvent e) {
    wait(true);
    super.tableChanged(e);
    if(ready) {
        // Create storage area
        ArrayList heights[] = new ArrayList[dataModel.getRowCount()];
        int widths_value[] = new int[dataModel.getColumnCount()];
        ArrayList widths[] = new ArrayList[dataModel.getColumnCount()];
        // Iterate through cell values finding tallest and widest for each row and column respectively.
        for(int j = 0; j < dataModel.getRowCount(); j++) {
        for(int k = 0; k < dataModel.getColumnCount(); k++) {
            Object object = dataModel.getValueAt(j, k);
            if(object instanceof ArrayList) {
            ArrayList data = (ArrayList) object;
            if(heights[j] == null || data.size() > heights[j].size()) {
                heights[j] = data;
            }
            String longest = "";
            for(int i = 0; i < data.size(); i++) {
                String temp = data.get(i).toString();
                if(temp.length() > longest.length()) {
                longest = temp;
                }
                temp = null;
            }
            if(widths[k] == null || longest.length() > widths_value[k]) {
                widths_value[k] = longest.length();
                widths[k] = data;
            }
            longest = null;
            data = null;
            }
        }
        }
        // Now assign the dimensions we have determined to be the largest.
        TableCellRenderer renderer = getDefaultRenderer(ArrayList.class);
        for(int l = 0; l < heights.length; l++) {
        if(heights[l] != null) {
            Component component = renderer.getTableCellRendererComponent(this, heights[l], false, false, 0, 0);
            Dimension size = component.getPreferredSize();
            setRowHeight(l, size.height);
            size = null;
            component = null;
        }
        }
        heights = null;
        for(int m = 0; m < widths.length; m++) {
        if(widths[m] != null) {
            Component component = renderer.getTableCellRendererComponent(this, widths[m], false, false, 0, 0);
            Dimension size = component.getPreferredSize();
            int width = size.width + MARGIN;
            if(width > (2 * parent_frame.getSize().width) / 3) {
            width = (2 * parent_frame.getSize().width) / 3;
            }
            Component header = header_renderer.getTableCellRendererComponent(this, dataModel.getColumnName(m), false, false, 0, 0);
            if(header.getPreferredSize().width + MARGIN > width) {
            width = header.getPreferredSize().width + MARGIN;
            }
            columnModel.getColumn(m).setPreferredWidth(width);
            size = null;
            component = null;
        }
        }
        widths = null;
        renderer = null;
    }
    wait(initial_state);
    }

    public void sortOrderChanged(TableModelSorterEvent event) {
    }

    private void wait(boolean waiting) {
    if(parent_frame != null) {
        parent_frame.wait(waiting);
    }
    }
}