source: trunk/gli/src/org/greenstone/gatherer/gui/EnrichPane.java@ 9334

/**
 *#########################################################################
 *
 * 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;


import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.collection.CollectionTree;
import org.greenstone.gatherer.collection.CollectionTreeNode;
import org.greenstone.gatherer.gui.tree.DragTree;
import org.greenstone.gatherer.metadata.MetadataElement;
import org.greenstone.gatherer.metadata.MetadataValue;
import org.greenstone.gatherer.metadata.MetadataValueTableEntry;
import org.greenstone.gatherer.metadata.MetadataValueTableModel;
import org.greenstone.gatherer.metadata.MetadataValueTreeModel;
import org.greenstone.gatherer.metadata.MetadataValueTreeNode;
import org.greenstone.gatherer.metadata.MetadataXMLFileManager;
import org.greenstone.gatherer.util.DragGroup;
import org.greenstone.gatherer.util.PatternTokenizer;
import org.greenstone.gatherer.util.TreeSynchronizer;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.util.XMLTools;


/** Provides a view of controls for the editing of metadata.
 */
public class EnrichPane
    extends JPanel
    implements ActionListener, TreeSelectionListener
{
    static private Dimension CONTROL_SIZE = new Dimension(560, 240);
    static private Dimension MINIMUM_SIZE = new Dimension(100, 100);
    static private Dimension TABLE_SIZE = new Dimension(560, 25);
    static private Dimension TREE_SIZE = new Dimension(250, 500);
    static private int MINIMUM_TABLE_HEADER_SIZE = 15;

    private MetadataValueTable metadata_value_table = null;
    /** The layout manager used to display either the MetadataValueTable (when files are selected) or a placeholder panel */
    private CardLayout metadata_value_table_card_layout = null;
    /** The name of the panel containing the metadata table */
    static final private String TABLE_CARD = "";
    /** The name of the panel containing the "no files selected" placeholder for the metadata table */
    static final private String TABLE_CARD_NO_FILES_SELECTED = "No files selected";
    /** The name of the panel containing the "no metadata available" placeholder for the metadata table */
    static final private String TABLE_CARD_NO_METADATA_AVAILABLE = "No metadata available";

    private JTextField metadata_value_text_field = null;
    /** The MetadataValueTree graphically shows the available metadata that has been previously assigned, and provides controls for adding, updating and removing metadata, depending on the user's selections in the other important components. */
    private MetadataValueTree metadata_value_tree = null;
    /** The layout manager used to display either the MetadataValueTree (when metadata is selected) or a placeholder panel */
    private CardLayout metadata_value_tree_card_layout = null;
    /** The name of the panel containing the metadata value tree */
    static final private String TREE_CARD = "";
    /** The name of the panel containing the "no metadata element selected" placeholder for the metadata table */
    static final private String TREE_CARD_NO_METADATA_ELEMENT_SELECTED  = "No metadata element selected";

    /** Used to dynamically filter the collection tree at user request. Note that this is synchronized with the collection tree filter in the Gather view. */
    private Filter collection_filter = null;
    /** The currently reported selection. */
    private CollectionTreeNode[] file_nodes = null;
    /** The button, which when clicked, adds metadata to the selected records. */
    private JButton add;
    /** The button, which when clicked, removes the selected metadata from the selected records. */
    private JButton remove;
    /** The button, which when clicked, updates the selected metadata from the selected records. */
    private JButton replace;
    /** This button creates an editor dialog to allow for an expanded area to type in text. */
    private JButton expand;
    private JButton expand_for_extracted;
    /** The label at the top of the collection tree, which shows the collection name. */
    private JLabel collection_label;
    /** The panel in which the metadata value card layout resides. */
    private JPanel control_pane;
    /** The panel in which the metadata table card layout resides. */
    private JPanel table_card_pane;
    /** The splitpane dividing the collection tree and the metadata based controls. */
    private JSplitPane external_split;
    /** The label shown at the top of the metadata table detailing the current selection statistics. */
    private JTextField table_label;
    /** A reference to the collection tree. */
    private CollectionTree collection_tree;
    /** Provide synchronization between the collection trees in this view and the collection pane view. */
    private TreeSynchronizer collection_tree_sync = null;
    private boolean metadata_edit_event = false;


    /** Constructor.
     * @param tree_sync The <strong>TreeSynchronizer</strong> to be used on the collection tree
     */
    public EnrichPane(TreeSynchronizer collection_tree_sync)
    {
    this.collection_tree_sync = collection_tree_sync;

    add = new GLIButton();
    add.addActionListener(this);
    add.setEnabled(false);
    add.setMnemonic(KeyEvent.VK_A);
    add.setPreferredSize(Utility.MINIMUM_BUTTON_SIZE);
    Dictionary.registerBoth(add, "EnrichPane.Accumulate", "EnrichPane.Accumulate_Tooltip");

    replace = new GLIButton();
    replace.addActionListener(this);
    replace.setEnabled(false);
    replace.setMnemonic(KeyEvent.VK_P);
    replace.setPreferredSize(Utility.MINIMUM_BUTTON_SIZE);
    Dictionary.registerBoth(replace, "EnrichPane.Overwrite", "EnrichPane.Overwrite_Tooltip");

    remove = new GLIButton();
    remove.addActionListener(this);
    remove.setEnabled(false);
    remove.setMnemonic(KeyEvent.VK_R);
    remove.setPreferredSize(Utility.MINIMUM_BUTTON_SIZE);
    Dictionary.registerBoth(remove, "EnrichPane.Remove", "EnrichPane.Remove_Tooltip");

    expand = new GLIButton();
    expand.addActionListener(this);
    expand.setEnabled(true);
    expand.setMnemonic(KeyEvent.VK_E);
    expand.setPreferredSize(new Dimension(25, 25));
    Dictionary.registerBoth(expand, "EnrichPane.Expand", "EnrichPane.Expand_Tooltip");

    expand_for_extracted = new GLIButton();
    expand_for_extracted.addActionListener(this);
    expand_for_extracted.setEnabled(true);
    expand_for_extracted.setMnemonic(KeyEvent.VK_E);
    expand_for_extracted.setPreferredSize(new Dimension(25, 25));
    Dictionary.registerBoth(expand_for_extracted, "EnrichPane.Expand", "EnrichPane.Expand_Tooltip");

    metadata_value_text_field = new JTextField();
    metadata_value_table = new MetadataValueTable();
    metadata_value_tree = new MetadataValueTree(CONTROL_SIZE.width, CONTROL_SIZE.height);
    }


    /** Called whenever an action occurs on one of our registered buttons.
     * @param event An <strong>ActionEvent</strong> containing information about the event.
     */
    public void actionPerformed(ActionEvent event)
    {
    Object esrc = event.getSource();

    // One of the metadata editing buttons was pressed
    if (esrc == add || esrc == replace || esrc == remove) {
        // Double-check that some files and a metadata element have been selected
        MetadataValueTableEntry selected_metadata_value_table_entry = metadata_value_table.getSelectedMetadataValueTableEntry();
        if (file_nodes == null || selected_metadata_value_table_entry == null) {
        return;
        }

        // If we're adding metadata to folders display the warning
        if (esrc == add && !file_nodes[0].isLeaf()) {
        WarningDialog dialog = new WarningDialog("warning.DirectoryLevelMetadata", null, true);
        int dialog_result = dialog.display();
        dialog.dispose();

        if (dialog_result != JOptionPane.OK_OPTION) {
            return;
        }
        }

        // Lock the interface so nothing can be changed while the metadata edit is being processed
        Gatherer.g_man.wait(true);

        // Add button pressed
        if (esrc == add) {
        MetadataElement metadata_element = metadata_value_table.getSelectedMetadataElement();
        MetadataValueTreeNode metadata_value_tree_node = metadata_element.addMetadataValue(metadata_value_tree.getSelectedValue());
        MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
        metadata_value.setIsAccumulatingMetadata(true);
        (new AppendMetadataTask(metadata_value)).run();
        }

        // Replace button pressed
        else if (esrc == replace) {
        MetadataElement metadata_element = metadata_value_table.getSelectedMetadataElement();
        MetadataValueTreeNode metadata_value_tree_node = metadata_element.addMetadataValue(metadata_value_tree.getSelectedValue());
        MetadataValue metadata_value = new MetadataValue(metadata_element, metadata_value_tree_node);
        metadata_value.setIsAccumulatingMetadata(!metadata_value_table.getSelectedMetadataValueTableEntry().isInheritedMetadata());
        (new ReplaceMetadataTask(metadata_value, selected_metadata_value_table_entry)).run();
        }

        // Remove button pressed
        else if (esrc == remove) {
        (new RemoveMetadataTask(selected_metadata_value_table_entry)).run();
        }

        // Note that the collection's metadata has been changed
        Gatherer.c_man.getCollection().setMetadataChanged(true);
    }

    // Expand button pressed
    else if (esrc == expand) {
        EditorDialog ed = new EditorDialog();
        String new_metadata_value = ed.display(metadata_value_tree.getSelectedValue());
        if (new_metadata_value != null) {
        metadata_value_tree.setSelectedValue(new_metadata_value);
        }
    }

    // Expand button for extracted metadata pressed
    else if (esrc == expand_for_extracted) {
        EditorDialog ed = new EditorDialog();
        ed.setEditable(false);
        ed.display(metadata_value_table.getSelectedMetadataValueTableEntry().getFullValue());
    }
    }


    /** Some actions can only occur after this panel has been displayed on-screen, so this method is provided to do exactly that. Such actions include the proportioning of the split panes and the setting of table column widths.
     */
    public void afterDisplay()
    {
    external_split.setDividerLocation(0.3);
    }


    /** Used to create, connect and layout the components to be shown on this control panel.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.file.FileOpenActionListener
     * @see org.greenstone.gatherer.gui.Filter
     */
    public void display()
    {
    // Creation
    JPanel collection_pane = new JPanel(new BorderLayout());
    collection_pane.setMinimumSize(MINIMUM_SIZE);
    collection_pane.setPreferredSize(TREE_SIZE);

    external_split = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT);

    collection_label = new JLabel();
    Dictionary.registerText(collection_label, "Collection.No_Collection");
    collection_label.setOpaque(true);

    DragGroup group = new DragGroup();
    collection_tree = new CollectionTree("Enrich", Gatherer.c_man.getCollectionTreeModel(), false);
    group.add(collection_tree);
    collection_tree.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
    collection_tree.putClientProperty("JTree.lineStyle", "Angled");
    collection_tree.addMouseListener(Gatherer.g_man.foa_listener);
    collection_tree.addMouseListener(new RightButtonListener());
    collection_tree.addTreeSelectionListener(this);
    collection_tree.addTreeExpansionListener(Gatherer.g_man.foa_listener);
    collection_tree.setBackgroundNonSelectionColor(Configuration.getColor("coloring.collection_tree_background", false));
    collection_tree.setTextNonSelectionColor(Configuration.getColor("coloring.collection_tree_foreground", false));
    collection_tree.setBackgroundSelectionColor(Configuration.getColor("coloring.collection_selection_background", false));
    collection_tree.setTextSelectionColor(Configuration.getColor("coloring.collection_selection_foreground", false));
    collection_tree.setRootVisible(false);

    KeyListenerImpl key_listener = new KeyListenerImpl();
    collection_tree.addKeyListener(key_listener);
    JScrollPane collection_scroll = new JScrollPane(collection_tree);

    collection_filter = Gatherer.g_man.getFilter(collection_tree);
    collection_filter.setBackground(Configuration.getColor("coloring.collection_heading_background", false));
    collection_filter.setEditable(Configuration.getMode() > Configuration.LIBRARIAN_MODE);
    Dictionary.registerTooltip(collection_filter.getComboBox(), "Collection.Filter_Tooltip");

    // Layout
    collection_pane.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(3,3,3,3), BorderFactory.createLoweredBevelBorder()));
    collection_pane.setMinimumSize(MINIMUM_SIZE);
    collection_pane.setPreferredSize(new Dimension(Gatherer.g_man.getSize().width / 3, Gatherer.g_man.getSize().height));

    // Collection Pane
    collection_pane.add(collection_label, BorderLayout.NORTH);
    collection_pane.add(collection_scroll, BorderLayout.CENTER);
    collection_pane.add(collection_filter, BorderLayout.SOUTH);

    JSplitPane main_split_pane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
    main_split_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
    main_split_pane.setDividerSize(8);

    // Metadata Table. In order to achieve what Ian envisions I'm going
    // to have to do a tricky. The table itself will sit in a stacked
    // CardLayout. Card zero will be a see-through JPanel with a message
    // smack bang in the center, something like "No Metadata". If any
    // page of the table would appear to have no metadata this card will
    // be swapped to the front.

    JPanel table_pane = new JPanel();
    table_pane.setBorder(BorderFactory.createEmptyBorder(5,0,5,0));

    JPanel table_title_pane = new JPanel();

    table_label = new JTextField();
    table_label.setBackground(Configuration.getColor("coloring.collection_tree_background", false));
    table_label.setEditable(false);
    Dictionary.registerText(table_label, "EnrichPane.No_File");

    table_card_pane = new JPanel();

    JPanel table_pane_zero = new JPanel();
    table_pane_zero.setOpaque(false);

    JPanel table_pane_two = new JPanel();
    table_pane_two.setOpaque(false);

    JLabel no_file_message = new JLabel();
    no_file_message.setHorizontalAlignment(JLabel.CENTER);
    no_file_message.setOpaque(false);
    no_file_message.setVerticalAlignment(JLabel.CENTER);
    Dictionary.registerText(no_file_message, "EnrichPane.No_File");

    JLabel no_metadata_message = new JLabel();
    no_metadata_message.setHorizontalAlignment(JLabel.CENTER);
    no_metadata_message.setOpaque(false);
    no_metadata_message.setVerticalAlignment(JLabel.CENTER);
    Dictionary.registerText(no_metadata_message, "EnrichPane.No_Metadata");

    JPanel table_pane_one = new JPanel();

    JScrollPane table_scroll = new JScrollPane(metadata_value_table);
    table_scroll.getViewport().setBackground(Configuration.getColor("coloring.collection_tree_background", false));
    table_scroll.setOpaque(true);

    // Create the cards for the metadata value table
    metadata_value_table_card_layout = new CardLayout();

    table_pane_zero.setLayout(new BorderLayout());
    table_pane_zero.add(no_file_message, BorderLayout.CENTER);

    table_pane_one.setLayout(new BorderLayout());
    table_pane_one.add(table_scroll, BorderLayout.CENTER);

    table_pane_two.setLayout(new BorderLayout());
    table_pane_two.add(no_metadata_message, BorderLayout.CENTER);

    table_card_pane.setLayout(metadata_value_table_card_layout);
    table_card_pane.add(table_pane_zero, TABLE_CARD_NO_FILES_SELECTED);
    table_card_pane.add(table_pane_one, TABLE_CARD);
    table_card_pane.add(table_pane_two, TABLE_CARD_NO_METADATA_AVAILABLE);

    // Create the cards for the metadata value tree
    metadata_value_tree_card_layout = new CardLayout();

    // Control pane
    control_pane = new JPanel();
    control_pane.setBorder(BorderFactory.createLoweredBevelBorder());
    control_pane.setMinimumSize(MINIMUM_SIZE);
    control_pane.setSize(CONTROL_SIZE);
    control_pane.setPreferredSize(CONTROL_SIZE);

    JPanel tools_off_pane = new JPanel();

    JLabel tools_off_label = new JLabel();
    tools_off_label.setHorizontalAlignment(JLabel.CENTER);
    tools_off_label.setOpaque(false);
    tools_off_label.setVerticalAlignment(JLabel.CENTER);
    Dictionary.registerText(tools_off_label, "EnrichPane.No_Metadata_Element");

    JPanel tools_on_pane = new JPanel();
    tools_on_pane.setMinimumSize(MINIMUM_SIZE);
    tools_on_pane.setSize(TABLE_SIZE);
    tools_on_pane.setPreferredSize(TABLE_SIZE);

    // Layout.

    // Metaedit controls
    tools_off_pane.setLayout(new BorderLayout());
    tools_off_pane.add(tools_off_label, BorderLayout.CENTER);

    tools_on_pane.setLayout(new BorderLayout());
    tools_on_pane.add(metadata_value_tree, BorderLayout.CENTER);

    control_pane.setLayout(metadata_value_tree_card_layout);
    control_pane.add(tools_off_pane, TREE_CARD_NO_METADATA_ELEMENT_SELECTED);
    control_pane.add(tools_on_pane, TREE_CARD);

    // Table components
    table_title_pane.setBorder(BorderFactory.createEmptyBorder(0,0,5,0));
    table_title_pane.setLayout(new BorderLayout());
    table_title_pane.add(table_label, BorderLayout.CENTER);

    table_pane.setLayout(new BorderLayout());
    table_pane.add(table_title_pane, BorderLayout.NORTH);
    table_pane.add(table_card_pane, BorderLayout.CENTER);

    main_split_pane.add(table_pane, JSplitPane.TOP);
    main_split_pane.add(control_pane, JSplitPane.BOTTOM);
    main_split_pane.setDividerLocation(250);

    external_split.add(collection_pane, JSplitPane.LEFT);
    external_split.add(main_split_pane, JSplitPane.RIGHT);

    this.setLayout(new BorderLayout());
    this.add(external_split, BorderLayout.CENTER);
    }


    /** Called to inform this control panel that it has just gained focus as an effect of the user clicking on its tab.
     */
    public void gainFocus()
    {
    // If there is nothing in the collection tree there is nothing to do
    if (collection_tree == null || collection_tree.getRowCount() == 0) {
        return;
    }

    // Select the first node in the tree if nothing is already selected
    if (collection_tree.getSelectionPaths() == null) {
        collection_tree.setImmediate(true);
        collection_tree.setSelectionRow(0);
        collection_tree.setImmediate(false);
        return;
    }

    // Force all of the controls to be updated
    valueChanged(new TreeSelectionEvent(this, null, false, null, null));
    }


    /** Called whenever the detail mode changes to ensure the filters are at an appropriate level (ie only editable by those that understand regular expression matching)
     * @param mode the mode level as an int
     */
    public void modeChanged(int mode)
    {
    collection_filter.setEditable(mode > Configuration.LIBRARIAN_MODE);
    }


    /** Refresh this pane, depending on what has just happened (refresh_reason). */
    public void refresh(int refresh_reason, boolean collection_loaded)
    {
    if (collection_loaded) {
        // Update collection label
        Dictionary.registerText(collection_label, "Collection.Collection");
        collection_label.setBackground(Configuration.getColor("coloring.collection_heading_background", false));
        collection_label.setForeground(Configuration.getColor("coloring.collection_heading_foreground", false));

        // Update collection tree
        if (refresh_reason == Gatherer.COLLECTION_OPENED) {
        collection_tree.setModel(Gatherer.c_man.getCollectionTreeModel());
        }

        // Update collection filter
        collection_filter.setBackground(Configuration.getColor("coloring.collection_heading_background", false));
    }
    else {
        // Update collection label
        Dictionary.registerText(collection_label, "Collection.No_Collection");
        collection_label.setBackground(Color.lightGray);
        collection_label.setForeground(Color.black);

        // Update collection tree
        collection_tree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("Error")));

        // Update collection filter
        collection_filter.setBackground(Color.lightGray);
    }

    // Enable or disable the controls
    collection_tree.setEnabled(collection_loaded);
    collection_filter.setEnabled(collection_loaded);

    // Ensure that this collection tree view is synchronized with all others
    collection_tree_sync.add(collection_tree);

    // Force the metadata table to be rebuilt (for switching extracted metadata on or off)
    if (refresh_reason == Gatherer.PREFERENCES_CHANGED) {
        valueChanged(null);
    }
    }


    /** This method is called whenever the selection within the collection
     * tree changes. This causes the table to be rebuilt with a new model.
     */
    public void valueChanged(TreeSelectionEvent event)
    {
    // Nothing selected in the collection tree
    if (collection_tree.getSelectionCount() == 0) {
        file_nodes = null;

        // Update the label to show nothing is selected in the collection tree
        Dictionary.registerText(table_label, "EnrichPane.No_File");

        // Display the "no file selected" card
        metadata_value_table_card_layout.show(table_card_pane, TABLE_CARD_NO_FILES_SELECTED);
    }

    // Some files selected in the collection tree
    else {
        TreePath paths[] = collection_tree.getSelectionPaths();
        file_nodes = new CollectionTreeNode[paths.length];
        for (int i = 0; i < paths.length; i++) {
        file_nodes[i] = (CollectionTreeNode) paths[i].getLastPathComponent();
        }

        // Update the label to show what is selected in the collection tree
        table_label.setText(collection_tree.getSelectionDetails());
    }

    // Update the metadata value table (and consequently, the metadata value tree)
    MetadataValue previously_selected_metadata_value = metadata_value_table.getSelectedMetadataValueTableEntry();
    metadata_value_table.rebuildAndSelectRowWithValueClosestTo(previously_selected_metadata_value);
    }


    private class AppendMetadataTask
    extends Thread
    {
    private MetadataValue metadata_value = null;

    private AppendMetadataTask(MetadataValue metadata_value)
    {
        this.metadata_value = metadata_value;
    }

    public void run()
    {
        try {
        // Edit metadata.xml files to add the metadata
        MetadataXMLFileManager.addMetadata(file_nodes, metadata_value);

        // Update the metadata value table and tree
        metadata_edit_event = true;
        metadata_value_table.rebuildAndSelectRowWithValueClosestTo(metadata_value);
        metadata_edit_event = false;
        }
        catch (Exception exception) {
        // We need to catch any exceptions here so the interface is unlocked below
        DebugStream.printStackTrace(exception);
        }

        // Operation finished, so turn busy cursor off and unlock interface
        Gatherer.g_man.wait(false);
    }
    }


    private class ReplaceMetadataTask
    extends Thread
    {
    private MetadataValue metadata_value = null;
    private MetadataValueTableEntry selected_metadata_value_table_entry = null;

    private ReplaceMetadataTask(MetadataValue metadata_value, MetadataValueTableEntry selected_metadata_value_table_entry)
    {
        this.metadata_value = metadata_value;
        this.selected_metadata_value_table_entry = selected_metadata_value_table_entry;
    }

    public void run()
    {
        try {
        // Edit metadata.xml files to replace the metadata
        MetadataXMLFileManager.removeMetadata(file_nodes, selected_metadata_value_table_entry);
        MetadataXMLFileManager.addMetadata(file_nodes, metadata_value);

        // Update the metadata value table and tree
        metadata_edit_event = true;
        metadata_value_table.rebuildAndSelectRowWithValueClosestTo(metadata_value);
        metadata_edit_event = false;
        }
        catch (Exception exception) {
        // We need to catch any exceptions here so the interface is unlocked below
        DebugStream.printStackTrace(exception);
        }

        // Operation finished, so turn busy cursor off and unlock interface
        Gatherer.g_man.wait(false);
    }
    }


    private class RemoveMetadataTask
    extends Thread
    {
    private MetadataValueTableEntry selected_metadata_value_table_entry = null;

    private RemoveMetadataTask(MetadataValueTableEntry selected_metadata_value_table_entry)
    {
        this.selected_metadata_value_table_entry = selected_metadata_value_table_entry;
    }

    public void run()
    {
        try {
        // Edit metadata.xml files to remove the metadata
        MetadataXMLFileManager.removeMetadata(file_nodes, selected_metadata_value_table_entry);

        // Update the metadata value table and tree
        metadata_edit_event = true;
        metadata_value_table.rebuildAndSelectRowWithValueClosestTo(selected_metadata_value_table_entry);
        metadata_edit_event = false;
        }
        catch (Exception exception) {
        // We need to catch any exceptions here so the interface is unlocked below
        DebugStream.printStackTrace(exception);
        }

        // Operation finished, so turn busy cursor off and unlock interface
        Gatherer.g_man.wait(false);
    }
    }


    private class MetadataValueTable
    extends JTable
    {
    private MetadataValueTableModel metadata_value_table_model = null;
    /** The currently selected metadata value table entry */
    private MetadataValueTableEntry selected_metadata_value_table_entry = null;


    public MetadataValueTable()
    {
        metadata_value_table_model = new MetadataValueTableModel();
        setModel(metadata_value_table_model);

        // We allow only one row to be selected at a time
        setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        getSelectionModel().addListSelectionListener(new MetadataValueTableListSelectionListener());

        // The default JTable doesn't quite have the desired properties - when a
        // table cell is clicked on, the table is scrolled so the cell is as
        // visible as possible. This means that the left-most cells can become
        // hidden. To fix this, the MouseInputHandler in BasicTableUI is removed
        // as a MouseListener on the table, and a very slightly altered copy is
        // added in its place (TableMouseInputHandler).
        MouseListener[] mls = getMouseListeners();
        for (int i = 0; i < mls.length; i++) {
        // Remove the instances of MouseInputHandler
        if (mls[i].toString().startsWith("javax.swing.plaf.basic.BasicTableUI$MouseInputHandler@")) {
            removeMouseListener(mls[i]);
        }
        }
        // Add the slightly-altered mouse listener
        addMouseListener(new TableMouseInputHandler());

        // We also have to ensure that the table column header hasn't gone on a severe Jenny Craig binge and has somehow lost 7/8th of its component size
        JTableHeader table_header = getTableHeader();
        Dimension table_header_preferred_size = table_header.getPreferredSize();
        if (table_header_preferred_size.height < MINIMUM_TABLE_HEADER_SIZE) {
        table_header_preferred_size.setSize(table_header_preferred_size.width, MINIMUM_TABLE_HEADER_SIZE);
        table_header.setPreferredSize(table_header_preferred_size);
        }

        // Set the table columns as we want them
        setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        Dimension table_size = getPreferredSize();
        TableColumnModel column_model = getColumnModel();

        TableColumn inherited_column = column_model.getColumn(0);
        inherited_column.setPreferredWidth(20);
        inherited_column.setCellRenderer(new MetadataValueTableCellRenderer(metadata_value_table_model));

        TableColumn element_column = column_model.getColumn(1);
        element_column.setPreferredWidth((TABLE_SIZE.width / 4) - 15);
        element_column.setCellRenderer(new MetadataValueTableCellRenderer(metadata_value_table_model));

        TableColumn value_column = column_model.getColumn(2);
        value_column.setPreferredWidth(((3 * TABLE_SIZE.width) / 4) - 30);
        value_column.setCellRenderer(new MetadataValueTableCellRenderer(metadata_value_table_model));
    }


    public MetadataElement getSelectedMetadataElement()
    {
        return selected_metadata_value_table_entry.getMetadataElement();
    }


    public MetadataValueTableEntry getSelectedMetadataValueTableEntry()
    {
        return selected_metadata_value_table_entry;
    }


    public boolean isSelectedMetadataValueTableEntryCommon()
    {
        return metadata_value_table_model.isCommon(selected_metadata_value_table_entry);
    }


    public void moveSelectionDown()
    {
        int new_row_to_select = getSelectedRow() + 1;
        if (new_row_to_select < metadata_value_table_model.getRowCount()) {
        changeSelection(new_row_to_select, 1, false, false);
        }
    }


    public void moveSelectionUp()
    {
        int new_row_to_select = getSelectedRow() - 1;
        if (new_row_to_select >= 0) {
        changeSelection(new_row_to_select, 1, false, false);
        }
    }


    public void rebuildAndSelectRowWithValueClosestTo(MetadataValue optimal_metadata_value_to_select_when_building_complete)
    {
        // We don't want a lot of ListSelectionEvents while the table is rebuilding
        clearSelection();

        // Rebuild the metadata value table model
        metadata_value_table_model.rebuild(file_nodes);

        // If the metadata value table is empty there isn't much to do
        if (metadata_value_table_model.getRowCount() == 0) {
        // ...except display the "no metadata available" card, unless no files are selected
        if (file_nodes != null) {
            metadata_value_table_card_layout.show(table_card_pane, TABLE_CARD_NO_METADATA_AVAILABLE);
        }
        return;
        }

        // Display the card with the metadata value table
        metadata_value_table_card_layout.show(table_card_pane, TABLE_CARD);

        // If we don't need to select a row in the table after rebuilding, we're done
        if (optimal_metadata_value_to_select_when_building_complete == null) {
        return;
        }

        MetadataElement optimal_metadata_element = optimal_metadata_value_to_select_when_building_complete.getMetadataElement();
        
        // Find the row containing the closest value to the optimal value
        int optimal_row_to_select = 0;
        for (int i = 0; i < metadata_value_table_model.getRowCount(); i++) {
        MetadataValueTableEntry metadata_value_table_entry = metadata_value_table_model.getMetadataValueTableEntry(i);
        MetadataElement metadata_element = metadata_value_table_entry.getMetadataElement();
        if (metadata_element.equals(optimal_metadata_element)) {
            // This row will be the optimal row, unless the next row matches better
            optimal_row_to_select = i;
        }

        int c = metadata_value_table_entry.compareTo(optimal_metadata_value_to_select_when_building_complete);
        if (c >= 0) {
            // We've either found an exact match, or there is no exact match, so stop here
            break;
        }
        }

        changeSelection(optimal_row_to_select, 1, false, false);
        metadata_value_text_field.requestFocus();
    }


    private class MetadataValueTableListSelectionListener
        implements ListSelectionListener
    {
        public void valueChanged(ListSelectionEvent event)
        {
        // We only want to handle one event per selection, so wait for the value to stabilise
        if (getSelectionModel().getValueIsAdjusting() == true) {
            return;
        }

        selected_metadata_value_table_entry = null;
        MetadataElement selected_metadata_element = null;
        String selected_metadata_value = "";

        // We have a SINGLE_SELECTION model set so there is at most one selection
        int selected_row = getSelectedRow();
        if (selected_row >= 0) {
            selected_metadata_value_table_entry = metadata_value_table_model.getMetadataValueTableEntry(selected_row);
            selected_metadata_element = selected_metadata_value_table_entry.getMetadataElement();
            MetadataValueTreeNode metadata_value_tree_node = selected_metadata_value_table_entry.getMetadataValueTreeNode();
            if (metadata_value_tree_node != null) {
            selected_metadata_value = metadata_value_tree_node.getFullValue();
            }
        }

        // Update the metadata value tree
        metadata_value_tree.rebuild(selected_metadata_element, selected_metadata_value);
        }
    }


    /** A direct copy of javax.swing.plaf.basic.BasicTableUI$MouseInputHandler, except for one change in adjustFocusAndSelection(). The purpose of this change is to always keep the left-most cells of the table row selected visible. */
    private class TableMouseInputHandler implements MouseInputListener
    {
        // Component receiving mouse events during editing.
        // May not be editorComponent.
        private Component dispatchComponent;
        private boolean selectedOnPress;

        //  The Table's mouse listener methods.

        public void mouseClicked(MouseEvent e) {}

        private void setDispatchComponent(MouseEvent e) {
        Component editorComponent = getEditorComponent();
        Point p = e.getPoint();
        Point p2 = SwingUtilities.convertPoint(metadata_value_table, p, editorComponent);
        dispatchComponent = SwingUtilities.getDeepestComponentAt(editorComponent,
                                     p2.x, p2.y);
        }

        private boolean repostEvent(MouseEvent e) {
        // Check for isEditing() in case another event has
        // caused the editor to be removed. See bug #4306499.
        if (dispatchComponent == null || !isEditing()) {
            return false;
        }
        MouseEvent e2 = SwingUtilities.convertMouseEvent(metadata_value_table, e, dispatchComponent);
        dispatchComponent.dispatchEvent(e2);
        return true;
        }

        private void setValueIsAdjusting(boolean flag) {
        getSelectionModel().setValueIsAdjusting(flag);
        getColumnModel().getSelectionModel().setValueIsAdjusting(flag);
        }

        private boolean shouldIgnore(MouseEvent e) {
        return e.isConsumed() || (!(SwingUtilities.isLeftMouseButton(e) && isEnabled()));
        }

        public void mousePressed(MouseEvent e) {
        if (e.isConsumed()) {
            selectedOnPress = false;
            return;
        }
        selectedOnPress = true;
        adjustFocusAndSelection(e);
        }

        void adjustFocusAndSelection(MouseEvent e) {
        if (shouldIgnore(e)) {
            return;
        }

        Point p = e.getPoint();
        int row = rowAtPoint(p);
        int column = columnAtPoint(p);
        // The autoscroller can generate drag events outside the Table's range.
        if ((column == -1) || (row == -1)) {
            return;
        }

        if (editCellAt(row, column, e)) {
            setDispatchComponent(e);
            repostEvent(e);
        }
        // Commented this out and added the line below it to keep the value text field in focus
        // else if (isRequestFocusEnabled()) {
        // requestFocus();
        // }
        metadata_value_text_field.requestFocus();

        CellEditor editor = getCellEditor();
        if (editor == null || editor.shouldSelectCell(e)) {
            boolean adjusting = (e.getID() == MouseEvent.MOUSE_PRESSED) ? true : false;
            setValueIsAdjusting(adjusting);

            // Special code for clicking the first column (folder-level metadata)
            if (column == 0) {
            selected_metadata_value_table_entry = metadata_value_table_model.getMetadataValueTableEntry(row);

            // If this metadata is inherited, switch to the folder it came from
            if (selected_metadata_value_table_entry.isInheritedMetadata()) {
                File folder_metadata_inherited_from = selected_metadata_value_table_entry.getFolderMetadataInheritedFrom();
                if (folder_metadata_inherited_from != null) {
                collection_tree.setSelection(folder_metadata_inherited_from);
                }
            }

            changeSelection(row, 0, e.isControlDown(), e.isShiftDown());
            }
            else {
            changeSelection(row, 1, e.isControlDown(), e.isShiftDown());
            }
        }
        }

        public void mouseReleased(MouseEvent e) {
        if (selectedOnPress) {
            if (shouldIgnore(e)) {
            return;
            }

            repostEvent(e);
            dispatchComponent = null;
            setValueIsAdjusting(false);
        } else {
            adjustFocusAndSelection(e);
        }
        }


        public void mouseEntered(MouseEvent e) {}

        public void mouseExited(MouseEvent e) {}

        //  The Table's mouse motion listener methods.

        public void mouseMoved(MouseEvent e) {}

        public void mouseDragged(MouseEvent e) {
        if (shouldIgnore(e)) {
            return;
        }

        repostEvent(e);

        CellEditor editor = getCellEditor();
        if (editor == null || editor.shouldSelectCell(e)) {
            Point p = e.getPoint();
            int row = rowAtPoint(p);
            int column = columnAtPoint(p);
            // The autoscroller can generate drag events outside the Table's range.
            if ((column == -1) || (row == -1)) {
            return;
            }
            changeSelection(row, column, false, true);
        }
        }
    }
    }


    /**
     * This class is a little bit complex, a little bit subtle, and a little bit odd.
     * The strange interaction model is due to the fact that it is very tightly
     * coupled to the EnrichPane.
     *
     * The interaction is complex because there are three separate controls that the
     * user may interact with, each of which can affect the other two. The three
     * controls are:
     *   - The "assigned metadata" table, at the top right of the meta edit pane.
     *   - The "metadata value" text field, where users can type in new values.
     *   - The "metadata value tree", which shows other values that have been
     *     assigned to the selected metadata element.
     *
     * The interactions are:
     *   - The "assigned metadata" table
     *     Users may select one (and only one) row in this table. Selecting a row
     *     chooses one metadata element. The text field will be set to the current
     *     value of the metadata element. This value will also be selected in the
     *     metadata value tree.
     *
     *   - The "metadata value" text field
     *     If the value the user has typed in this is a prefix of an entry in the
     *     value tree, this value will be selected in the value tree. In this case,
     *     pressing "Tab" will complete the value (ie. make the value in the text
     *     field the same as the value in the tree). This is to allow users to
     *     quickly and easily assign existing metadata values to new documents.
     *
     *   - The "metadata value tree"
     *     Selecting a value in the tree will set the text field to this value.
     */
    private class MetadataValueTree
    extends JPanel
    {
    private boolean ignore_tree_selection_event = false;
    private boolean manual_text_edit_event = false;
    private CardLayout card_layout;
    private String card_showing = null;
    /** The metadata element that is currently selected. */
    private MetadataElement selected_metadata_element = null;
    private JTextArea extracted_message;
    private JTree tree;

    static final private String NONE = "None";
    static final private String TREE = "Tree";


    public MetadataValueTree(int width, int height)
    {
        super();

        setFont(Configuration.getFont("general.font", false));
        setPreferredSize(new Dimension(width, height));

        JPanel metadata_pane = new JPanel();

        JPanel value_pane = new JPanel();
        JLabel value_label = new JLabel();
        Dictionary.registerText(value_label, "EnrichPane.Value");

        JPanel value_field_pane = new JPanel();
        metadata_value_text_field.setBackground(Configuration.getColor("coloring.editable_background", false));
        metadata_value_text_field.setForeground(Configuration.getColor("coloring.editable_foreground", false));
        metadata_value_text_field.setPreferredSize(new Dimension(413, 24));
        metadata_value_text_field.getDocument().addDocumentListener(new DocumentListenerImpl());
        metadata_value_text_field.addKeyListener(new MetadataValueTextFieldKeyListener());
        metadata_value_text_field.setFocusTraversalKeysEnabled(false);
        Dictionary.setTooltip(metadata_value_text_field, "EnrichPane.Value_Field_Tooltip");

        JPanel button_pane = new JPanel();

        JPanel tree_pane = new JPanel();
        JLabel tree_label = new JLabel();
        Dictionary.registerText(tree_label, "EnrichPane.Tree");

        tree = new JTree();
        tree.addMouseListener(new MetadataValueTreeMouseListener());
        tree.addTreeSelectionListener(new MetadataValueTreeSelectionListener());
        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.setRootVisible(false);
        tree.putClientProperty("JTree.lineStyle", "Angled");

        JPanel extracted_pane = new JPanel();
        JPanel extracted_header_pane = new JPanel();
        extracted_message = new JTextArea("");
        extracted_message.setEditable(false);
        extracted_message.setLineWrap(true);
        extracted_message.setOpaque(false);
        extracted_message.setWrapStyleWord(true);

        card_layout = new CardLayout();

        // Layout
        value_field_pane.setBorder(BorderFactory.createEmptyBorder(0,5,0,5));
        value_field_pane.setLayout(new BorderLayout(0, 0));
        value_field_pane.add(metadata_value_text_field, BorderLayout.CENTER);

        button_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
        button_pane.setLayout(new GridLayout());
        button_pane.add(add);
        button_pane.add(replace);
        button_pane.add(remove);

        value_pane.setBorder(BorderFactory.createEmptyBorder(0,0,5,0));
        value_pane.setLayout(new BorderLayout());
        value_pane.add(value_label, BorderLayout.WEST);
        value_pane.add(value_field_pane, BorderLayout.CENTER);
        value_pane.add(expand, BorderLayout.EAST);
        value_pane.add(button_pane, BorderLayout.SOUTH);

        tree_pane.setLayout(new BorderLayout());
        tree_pane.add(tree_label, BorderLayout.NORTH);
        tree_pane.add(new JScrollPane(tree), BorderLayout.CENTER);

        metadata_pane.setLayout(new BorderLayout());
        metadata_pane.add(value_pane, BorderLayout.NORTH);
        metadata_pane.add(tree_pane, BorderLayout.CENTER);

        extracted_header_pane.setLayout(new BorderLayout());
        extracted_header_pane.add(expand_for_extracted, BorderLayout.EAST);

        extracted_pane.setBorder(BorderFactory.createEmptyBorder(0,10,25,0));
        extracted_pane.setLayout(new BorderLayout());
        extracted_pane.add(extracted_header_pane, BorderLayout.NORTH);
        extracted_pane.add(extracted_message, BorderLayout.CENTER);

        this.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        this.setLayout(card_layout);
        this.add(metadata_pane, TREE);
        this.add(extracted_pane, NONE);
        card_showing = TREE;
    }


    /** Returns a TreePath for the node most closely matching the metadata value. */
    private TreePath getClosestPath(String val)
    {
        // Start at the root of the tree
        MetadataValueTreeNode tree_node = (MetadataValueTreeNode) tree.getModel().getRoot();

        // Separate hierarchical values
        PatternTokenizer tokenizer = new PatternTokenizer(val, MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN);
        while (tokenizer.hasMoreTokens()) {
        String token = tokenizer.nextToken();

        // All components except the last must match exactly
        if (tokenizer.hasMoreTokens()) {
            for (int i = 0; i < tree_node.getChildCount(); i++) {
            MetadataValueTreeNode child_node = (MetadataValueTreeNode) tree_node.getChildAt(i);
            if (child_node.getValue().equals(token)) {
                // The matching node has been found, so move onto the next token
                tree_node = child_node;
                break;
            }
            }
        }

        // The last component may match partially
        else {
            for (int i = 0; i < tree_node.getChildCount(); i++) {
            MetadataValueTreeNode child_node = (MetadataValueTreeNode) tree_node.getChildAt(i);
            if (child_node.getFullValue().startsWith(val)) {
                // The closest node has been found, so return its path
                return new TreePath(child_node.getPath());
            }
            }

            // Not even a partial match
            return null;
        }
        }

        // If nothing else, return the path of the root node
        return new TreePath(tree_node.getPath());
    }


    public String getSelectedValue()
    {
        String metadata_value_raw = metadata_value_text_field.getText();
        String metadata_value = XMLTools.removeInvalidCharacters(metadata_value_raw);
        return metadata_value.replaceAll("\\\\", MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN);
    }


    public void rebuild(MetadataElement metadata_element, String metadata_value)
    {
        // System.err.println("In MetadataValueTree.rebuild()...");

        // Clear selection
        if (metadata_element == null) {
        if (metadata_edit_event == false) {
            // System.err.println("Clearing selection...");
            selected_metadata_element = null;
            validateDisplay();
        }
        return;
        }

        // Reload the value tree model if the selected metadata element has changed
        if (selected_metadata_element != metadata_element) {
        selected_metadata_element = metadata_element;
        tree.setModel(selected_metadata_element.getMetadataValueTreeModel());
        }

        validateDisplay();

        setSelectedValue(metadata_value);
    }


    /** This function is copied from JTree::setPathToVisible(), and modified so tree rows
        are always shown flushed left. Note: doesn't do accessibleContext stuff. */
    private void scrollTreePathToVisible(TreePath path)
    {
        if (path != null) {
        tree.makeVisible(path);

        Rectangle bounds = tree.getPathBounds(path);
        if (bounds != null) {
            bounds.width += bounds.x;
            bounds.x = 0;
            tree.scrollRectToVisible(bounds);
        }
        }
    }


    /** Sets the value in the text field. */
    private void setSelectedValue(String metadata_value)
    {
        // Setting the text of the field causes the DocumentListener to be notified, and
        //   updating the tree is handled there (DocumentListenerImpl::validate())
        if (!card_showing.equals(NONE)) {
        manual_text_edit_event = metadata_value.equals("");  // Set to false unless val == ""
        metadata_value_text_field.setText(metadata_value);
        manual_text_edit_event = true;
        }
    }


    private void validateDisplay()
    {
        // If no metadata is selected in the metadata value table, display "no metadata element selected" card
        if (file_nodes == null || selected_metadata_element == null) {
        metadata_value_tree_card_layout.show(control_pane, TREE_CARD_NO_METADATA_ELEMENT_SELECTED);
        }

        // Otherwise, display the card with the metadata value tree
        else {
        metadata_value_tree_card_layout.show(control_pane, TREE_CARD);

        // Special case the extracted metadata set
        if (selected_metadata_element.getNamespace().equals(Utility.EXTRACTED_METADATA_NAMESPACE)) {
            // Display the panel showing the "you cannot edit this metadata" message
            String[] args = new String[1];
            args[0] = selected_metadata_element.getFullName();
            Dictionary.registerText(extracted_message, "EnrichPane.AutoMessage", args);
            card_layout.show(this, NONE);
            card_showing = NONE;
        }
        else {
            // Display the panel for viewing and assigning metadata
            card_layout.show(this, TREE);
            card_showing = TREE;
        }

        // Validate the buttons above the value tree
        MetadataValueTableEntry metadata_value_table_entry = metadata_value_table.getSelectedMetadataValueTableEntry();
        if (metadata_value_table_entry.getValue().equals("")) {
            // Can only append if something has been entered
            add.setEnabled((getSelectedValue().length() > 0));

            // Nothing to replace or remove
            replace.setEnabled(false);
            remove.setEnabled(false);
            return;
        }

        // Check if the text in the value field is the same as the metadata value
        if (getSelectedValue().equals(metadata_value_table_entry.getFullValue())) {
            // Can't replace
            replace.setEnabled(false);

            // Adding, however, is dependant on whether the selected metadata is common or uncommon. If the later then you can append so as to make it common.
            add.setEnabled(!metadata_value_table.isSelectedMetadataValueTableEntryCommon());
        }
        else {
            // Can append or replace, if something has been entered
            add.setEnabled((getSelectedValue().length() > 0));
            replace.setEnabled((getSelectedValue().length() > 0));
        }

        // Can only remove if the metadata is file level
        if (metadata_value_table_entry != null) {  // Shouldn't be necessary, but is
            remove.setEnabled((metadata_value_table_entry.isInheritedMetadata() == false));
        }
        }
    }


    private class MetadataValueTextFieldKeyListener
        extends KeyAdapter
    {
        /** Gives notification of key events on the text field */
        public void keyPressed(KeyEvent e)
        {
        // Tab: Auto-complete
        if (e.getKeyCode() == KeyEvent.VK_TAB) {
            if (tree.getSelectionCount() != 0 && !getSelectedValue().equals("")) {
            TreePath path = tree.getSelectionPath();
            MetadataValueTreeNode node = (MetadataValueTreeNode) path.getLastPathComponent();
            setSelectedValue(node.getFullValue());
            }
        }

        // Enter: Append the metadata value, if we're allowed to
        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
            if (add.isEnabled()) {
            add.doClick();
            }
        }

        // Down: Change the metadata value table selection
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            metadata_value_table.moveSelectionDown();
        }

        // Up: Change the metadata value table selection
        if (e.getKeyCode() == KeyEvent.VK_UP) {
            metadata_value_table.moveSelectionUp();
        }
        }
    }


    private class MetadataValueTreeMouseListener
        extends MouseAdapter
    {
        public void mouseClicked(MouseEvent e)
        {
        // Double click: assign the selected value tree node immediately (if possible)
        if (e.getClickCount() == 2 && tree.getSelectionCount() != 0) {
            TreePath path = tree.getSelectionPath();
            MetadataValueTreeNode node = (MetadataValueTreeNode) path.getLastPathComponent();

            // Leaf nodes only (folder nodes will expand/contract)
            if (node.getChildCount() == 0 && add.isEnabled()) {
            add.doClick();
            }
        }
        }
    }


    private class MetadataValueTreeSelectionListener
        implements TreeSelectionListener
    {
        public void valueChanged(TreeSelectionEvent event)
        {
        // Select a node in the tree: fill the metadata value text field with the selected node's value
        if (tree.getSelectionCount() != 0 && !ignore_tree_selection_event) {
            TreePath path = tree.getSelectionPath();
            MetadataValueTreeNode node = (MetadataValueTreeNode) path.getLastPathComponent();
            setSelectedValue(node.getFullValue());
        }
        }
    }


    private class DocumentListenerImpl
        implements DocumentListener
    {
        /** Gives notification that an attribute or set of attributes changed */
        public void changedUpdate(DocumentEvent e) {
        validate();
        }

        /** Gives notification that there was an insert into the document */
        public void insertUpdate(DocumentEvent e) {
        validate();
        }

        /** Gives notification that a portion of the document has been removed */
        public void removeUpdate(DocumentEvent e) {
        validate();
        }


        /** Ensures that the value text field and value tree are synchronized */
        private void validate()
        {
        String value_text = getSelectedValue();

        // Ignore the validate() with empty text that occurs when value.setText() is used
        if (!value_text.equals("") || manual_text_edit_event == true) {
            TreePath closest_path = getClosestPath(value_text);

            // Select the new path in the tree
            // The tree selection event this causes must be ignored, since it alters value
            ignore_tree_selection_event = true;
            tree.setSelectionPath(closest_path);
            ignore_tree_selection_event = false;

            // If a folder has been specified, make sure it is expanded
            if (value_text.endsWith(MetadataValueTreeNode.METADATA_VALUE_TREE_NODE_HIERARCHY_TOKEN) && !tree.isExpanded(closest_path)) {
            tree.expandPath(closest_path);
            }

            // Make sure the path is visible on the screen
            scrollTreePathToVisible(closest_path);
            // One call should be enough, but it isn't in some cases (for some reason)
            scrollTreePathToVisible(closest_path);

            // Update the status of the buttons
            validateDisplay();
        }
        }
    }
    }


    /** This class listens for certain key presses, such as [Up] or [Down], -copied from Gather Pane */
    private class KeyListenerImpl
    extends KeyAdapter {
    private boolean vk_left_pressed = false;
    /** Called whenever a key that was pressed is released, it is this action that will cause the desired effects (this allows for the key event itself to be processed prior to this listener dealing with it). */
    public void keyReleased(KeyEvent event) {
        ///ystem.err.println("Key Release detected. " + event.getKeyCode());
        if (event.getKeyCode() == KeyEvent.VK_UP || event.getKeyCode() == KeyEvent.VK_DOWN) {
        DragTree tree = (DragTree)event.getSource();
        // we need to manually do the up and down selections
        boolean up = (event.getKeyCode() == KeyEvent.VK_UP);
        int current_row = tree.getLeadSelectionRow();
        tree.setImmediate(true);
        if (up) {
            if (current_row > 0) {
            tree.clearSelection();
            tree.setSelectionRow(current_row-1);
            }
        } else {
            if (current_row < tree.getRowCount()-1){
            tree.clearSelection();
            tree.setSelectionRow(current_row+1);
            }
        }
        tree.setImmediate(false);
        }
        else if (event.getKeyCode() == KeyEvent.VK_LEFT) {
        // left key on a file shifts the selection to the parent folder
        DragTree tree = (DragTree)event.getSource();
        TreePath path = tree.getLeadSelectionPath();
        if(path != null) {
            File file = ((CollectionTreeNode) path.getLastPathComponent()).getFile();
            if(file != null) {
            if (file.isFile() || vk_left_pressed) {
                vk_left_pressed = false;
                TreePath parent_path = path.getParentPath();
                if (parent_path != null && parent_path.getParentPath() != null) {
                // if this file is in the top level folder, don't move the focus 
                tree.setImmediate(true);
                tree.clearSelection();
                tree.setSelectionPath(parent_path);
                tree.setImmediate(false);
                }
            }
            }
        }
        }       
    }

    // we need to watch for left clicks on an unopened folder - should shift the focus to teh parent folder. But because there is some other mysterious key listener that does opening and closing folders on right and left clicks, we must detect the situation before the other handler has done its job, and process it after. 
    public void keyPressed(KeyEvent event) {
        if (event.getKeyCode() == KeyEvent.VK_LEFT) {
        // left key on  closed directory shifts the selection to the parent folder
        DragTree tree = (DragTree)event.getSource();
        TreePath path = tree.getLeadSelectionPath();
        if(path == null) return; 
        File file = ((CollectionTreeNode) path.getLastPathComponent()).getFile();
        if(file == null) return;
        
        if (file.isDirectory() && tree.isCollapsed(path)) {
            vk_left_pressed = true;
        }       
        }
    }
    }


    /** A listener for right mouse button clicks over the collection tree. */
    private class RightButtonListener
    extends MouseAdapter {
    /** Called whenever a mouse click occurs (right or left) over a target component.
     * @param event A <strong>MouseEvent</strong> containing further information about the mouse click action.
     * @see org.greenstone.gatherer.gui.EnrichPane.RightButtonMenu
     */
    public void mouseClicked(MouseEvent event) {
        if (SwingUtilities.isRightMouseButton(event)) {
        new RightButtonMenu(event);
        }
    }
    }


    /** When a user right-clicks within the collection tree they are presented with a small popup menu of context based options. This class provides such functionality.
     */
    private class RightButtonMenu
    extends JPopupMenu
    implements ActionListener {

    /** The tree over which the right click action occurred. */
    private DragTree tree = null;
    /** The tree nodes selected when the right click action occurred. */
    private TreePath[] selection_paths = null;
    /** The file record over which the right click action occurred. */
    private CollectionTreeNode node = null;

    private JMenuItem collapse_folder = null;
    private JMenuItem expand_folder = null;
    private JMenuItem metaaudit = null;
    private JMenuItem open_externally = null;


    private RightButtonMenu(MouseEvent event)
    {
        super();
        this.tree = collection_tree;

        // Note we have to use setImmediate() with the set selction paths
        // otherwise the selection doesn't get updated until after the 
        // popup comes up.

        // the right click position
        TreePath right_click_path = tree.getPathForLocation(event.getX(), event.getY());
        if (right_click_path == null) {
        // user has clicked outside of the tree, clear the selection
        selection_paths = null;
        tree.setImmediate(true);
        tree.clearSelection();
        tree.setImmediate(false);
        } else {
        // Get the paths currently selected in the tree
        selection_paths = tree.getSelectionPaths();
        if (selection_paths == null) {
            // nothing currently selected - we shift the selection to 
            // the node that was right clicked on
            selection_paths = new TreePath[1];
            selection_paths[0] = right_click_path;
            tree.setImmediate(true);
            tree.setSelectionPath(right_click_path);
            tree.setImmediate(false);
        } else if (selection_paths.length == 1 && ! selection_paths[0].equals( right_click_path)) {
            tree.setImmediate(true);
            tree.clearSelection();
            tree.setSelectionPath(right_click_path);
            tree.setImmediate(false);
            selection_paths[0] = right_click_path;
        } else {
            // we had multiply selected paths in the tree.
            // if we clicked on one of those paths, then use all the 
            // current selection, otherwise clear the selection and 
            // select the one we right clicked on
            boolean clicked_in_selection = false;
            for (int i=0; i<selection_paths.length; i++) {
            if (selection_paths[i].equals(right_click_path)) {
                clicked_in_selection = true;
                break;
            }
            }
            if (!clicked_in_selection) {
            // want the tree to update right away
            tree.setImmediate(true);
            tree.clearSelection();
            tree.setSelectionPath(right_click_path);
            tree.setImmediate(false);
            selection_paths = new TreePath[1];
            selection_paths[0] = right_click_path;
            }
        }
        }
        // finally we have the correct selection paths!!

        // Create an appropriate context menu, based on what is selected
        buildContextMenu(selection_paths);

        // Show the popup menu on screen
        show(tree, event.getX(), event.getY());
    }


    private void buildContextMenu(TreePath[] selection_paths)
    {
        // If nothing is selected, no options are available
        if (selection_paths == null) {
        return;
        }

        DebugStream.println("Number of files/folders selected: " + selection_paths.length);

        // Always have meta-audit option
        metaaudit = new JMenuItem(Dictionary.get("Menu.Metadata_View", collection_tree.getSelectionDetails()), KeyEvent.VK_A);
        metaaudit.addActionListener(this);
        add(metaaudit);

        // Only meta-audit is available if multiple items are selected...
        if (selection_paths.length > 1) {
        return;
        }

        TreePath path = selection_paths[0];
        node = (CollectionTreeNode) path.getLastPathComponent();

        // ---- Options for file nodes ----
        if (node.isLeaf()) {
        // Open the file in an external program
        open_externally = new JMenuItem(Dictionary.get("Menu.Open_Externally"), KeyEvent.VK_O);
        open_externally.addActionListener(this);
        add(open_externally);
        return;
        }

        // ---- Options for folder nodes ----
        // Collapse or expand, depending on current status
        if (tree.isExpanded(path)) {
        collapse_folder = new JMenuItem(Dictionary.get("Menu.Collapse"), KeyEvent.VK_C);
        collapse_folder.addActionListener(this);
        add(collapse_folder);
        }
        else {
        expand_folder = new JMenuItem(Dictionary.get("Menu.Expand"), KeyEvent.VK_O);
        expand_folder.addActionListener(this);
        add(expand_folder);
        }
    }


    /** Called whenever one of the menu items is clicked, this method then causes the appropriate effect. */
    public void actionPerformed(ActionEvent event)
    {
        Object source = event.getSource();

        // Collapse folder
        if (source == collapse_folder) {
        tree.collapsePath(selection_paths[0]);
        }

        // Expand folder
        else if (source == expand_folder) {
        tree.expandPath(selection_paths[0]);
        }

        // Meta-audit
        else if (source == metaaudit) {
        Gatherer.g_man.showMetaAuditBox();
        }

        // Open in external program
        else if (source == open_externally) {
        Gatherer.self.spawnApplication(node.getFile());
        }
    }
    }
}