source: trunk/gli/src/org/greenstone/gatherer/metadata/MetadataValueTableModel.java@ 8013

package org.greenstone.gatherer.metadata;


import java.awt.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.table.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.file.FileNode;
import org.greenstone.gatherer.gui.WarningDialog;


public class MetadataValueTableModel
    extends AbstractTableModel
{
    /** The FileNodes this model is built for */
    private FileNode[] file_nodes = null;
    /** The list of MetadataValueTableEntries in the table */
    private ArrayList metadata_value_table_entries = new ArrayList();

    static final private String[] COLUMN_NAMES = { "", Dictionary.get("Metadata.Element"), Dictionary.get("Metadata.Value") };


    /** Returns the number of columns in this table. */
    public int getColumnCount()
    {
    return COLUMN_NAMES.length;
    }


    /** Retrieves the name of the specified column. */
    public String getColumnName(int col)
    {
    return COLUMN_NAMES[col];
    }


    /* Called to retrieve the MetadataValueTableEntry at a certain row. Usually caused by the user selecting a row in the table. It is synchronized so that the model doesn't up and change while we're trying to retrieve the indicated element. */
    public synchronized MetadataValueTableEntry getMetadataValueTableEntry(int row)
    {
    if (row >= 0 && row < metadata_value_table_entries.size()) {
        return (MetadataValueTableEntry) metadata_value_table_entries.get(row);
    }

    return null;
    }


    /** Returns the number of rows in this table. */
    public int getRowCount()
    {
    return metadata_value_table_entries.size();
    }


    /** Returns the cell value at a given row and column as an Object. */
    public Object getValueAt(int row, int col)
    {
    // Check values are reasonable
    if (row < 0 || row >= metadata_value_table_entries.size() || col < 0 || col >= COLUMN_NAMES.length) {
        return null;
    }

    MetadataValueTableEntry metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(row);
    if (col == 0 && metadata_value_table_entry.isInheritedMetadata()) {
        return metadata_value_table_entry.getFolderMetadataInheritedFrom();
    }

    if (col == 1) {
        return metadata_value_table_entry.getMetadataElement();
    }

    if (col == 2) {
        return metadata_value_table_entry.getFullValue();
    }

    return null;
    }


    /** Determine if the given metadata is common to all selected file nodes given the context of the current view. */
    public boolean isCommon(MetadataValueTableEntry metadata_value_table_entry)
    {
    return (file_nodes != null && metadata_value_table_entry.getOccurrences() == file_nodes.length);
    }


    /** Determine if the given metadata is common to all selected file nodes given the context of the current view. */
    public boolean isCommon(int row)
    {
    if (row >= 0 && row < metadata_value_table_entries.size()) {
        return isCommon((MetadataValueTableEntry) metadata_value_table_entries.get(row));
    }

    return false;
    }


    public void rebuild(FileNode[] file_nodes)
    {
    metadata_value_table_entries.clear();

    if (!Gatherer.c_man.ready()) {
        Gatherer.println("Not ready!");
        return;
    }

    this.file_nodes = file_nodes;
    if (file_nodes != null && file_nodes.length > 0) {
        // Create model builder
        MetadataValueTableModelBuilder builder = new MetadataValueTableModelBuilder();
        builder.run();
    }
    }


    private class MetadataValueTableModelBuilder
    {
    public void run()
    {
        // Build a list of MetadataValueTableEntries that represent the metadata asssigned to the selected files
        boolean hid_extracted_metadata = false;
        boolean has_inherited_metadata = false;
        ArrayList metadata_elements_seen = new ArrayList();

        // Process each of the selected files in turn
        for (int i = 0; i < file_nodes.length; i++) {
        File current_file = file_nodes[i].getFile();

        // Get the metadata assigned to this file
        ArrayList assigned_metadata = MetadataXMLFileManager.getMetadataAssignedToFile(current_file);
        for (int j = 0; j < assigned_metadata.size(); j++) {
            MetadataValue metadata_value = (MetadataValue) assigned_metadata.get(j);
            MetadataElement metadata_element = metadata_value.getMetadataElement();

            // Note if there is inherited (folder-level) metadata in the table
            has_inherited_metadata = has_inherited_metadata || metadata_value.isInheritedMetadata();

            // Insert this metadata value into the table, unless it already exists (in which case increment its count)
            insertMetadataValueIntoTable(metadata_value);

            // Remember we have seen this metadata element
            if (metadata_elements_seen.contains(metadata_element) == false) {
            metadata_elements_seen.add(metadata_element);
            }
        }

        // Get the extracted metadata for this file, if desired
        if (Gatherer.config.get("general.view_extracted_metadata", Configuration.COLLECTION_SPECIFIC) == true) {
            ArrayList extracted_metadata = DocXMLFileManager.getMetadataExtractedFromFile(current_file);
            for (int k = 0; k < extracted_metadata.size(); k++) {
            MetadataValue metadata_value = (MetadataValue) extracted_metadata.get(k);

            // Insert this metadata value into the table, unless it already exists (in which case increment its count)
            insertMetadataValueIntoTable(metadata_value);
            }
        }
        }

        // Make sure each non-extracted metadata element appears in the table (even if blank)
        ArrayList every_metadata_set_element = MetadataSetManager.getEveryMetadataSetElement();
        for (int i = 0; i < every_metadata_set_element.size(); i++) {
        MetadataElement metadata_element = (MetadataElement) every_metadata_set_element.get(i);

        // If we haven't seen this metadata element and it isn't extracted, add it now
        if (!metadata_elements_seen.contains(metadata_element) && !metadata_element.isExtractedMetadata()) { 
            MetadataValueTableEntry metadata_value_table_entry = new MetadataValueTableEntry(metadata_element, new MetadataValueTreeNode(""));

            // Blank metadata is common to all selected files (otherwise it wouldn't be blank!)
            metadata_value_table_entry.setOccurrences(file_nodes.length);

            // Add it to the table
            insertMetadataValueIntoTable(metadata_value_table_entry);
        }
        }

        // If extracted metadata was hidden, display the warning
        if (hid_extracted_metadata) {
        showExtractedMetadataWarning();
        }

        // If there is inherited metadata, display the warning
        if (has_inherited_metadata) {
        showInheritedMetadataWarning();
        }
    }


    /** Alphabetically inserts the new metadata value into the table */
    private void insertMetadataValueIntoTable(MetadataValue metadata_value)
    {
        for (int i = 0; i < metadata_value_table_entries.size(); i++) {
        MetadataValueTableEntry current_metadata_value_table_entry = (MetadataValueTableEntry) metadata_value_table_entries.get(i);
        int c = current_metadata_value_table_entry.compareTo(metadata_value);

        // Insert value before existing entry
        if (c > 0) {
            metadata_value_table_entries.add(i, new MetadataValueTableEntry(metadata_value));
            fireTableRowsInserted(i, i);
            return;
        }

        // Entry already exists (increment existing count)
        if (c == 0) {
            current_metadata_value_table_entry.anotherOccurrence();
            return;
        }
        }

        // Must go at the end of the table
        metadata_value_table_entries.add(new MetadataValueTableEntry(metadata_value));
        fireTableRowsInserted(metadata_value_table_entries.size() - 1, metadata_value_table_entries.size() - 1);
    }


    private void showExtractedMetadataWarning()
    {
        Runnable task = new Runnable() {
            public void run() {
            WarningDialog dialog = new WarningDialog("warning.ExtractedMetadata", false);
            dialog.display();
            dialog.dispose();
            dialog = null;
            }
        };
        SwingUtilities.invokeLater(task);
    }


    private void showInheritedMetadataWarning()
    {
        Runnable task = new Runnable() {
            public void run() {
            WarningDialog dialog = new WarningDialog("warning.InheritedMetadata", false);
            dialog.display();
            dialog.dispose();
            dialog = null;
            }
        };
        SwingUtilities.invokeLater(task);
    }
    }
}