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

/**
 *#########################################################################
 *
 * 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.border.*;
import javax.swing.event.*;
import javax.swing.table.*;
import javax.swing.tree.*;
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.Filter;
import org.greenstone.gatherer.gui.GComboBox;
import org.greenstone.gatherer.gui.GLIButton;
import org.greenstone.gatherer.gui.MetaEditPrompt;
import org.greenstone.gatherer.gui.WarningDialog;
import org.greenstone.gatherer.gui.table.GTableModel;
import org.greenstone.gatherer.gui.table.TableCellRenderer;
import org.greenstone.gatherer.gui.tree.DragTree;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.msm.Metadata;
import org.greenstone.gatherer.msm.MSMEvent;
import org.greenstone.gatherer.msm.MSMListener;
import org.greenstone.gatherer.util.ArrayTools;
import org.greenstone.gatherer.util.Codec;
import org.greenstone.gatherer.util.DragGroup;
import org.greenstone.gatherer.util.PatternTokenizer;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.TreeSynchronizer;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.valuetree.GValueModel;
import org.greenstone.gatherer.valuetree.GValueNode;
/** Provides a view of controls for the editing of metadata. It makes use of several other important components such as a GTree, GTable and GValueTree. While much of the gui content is left to these components, the EnrichPane is resposible for actioning metadata edit requests, listing for mouse clicks within its scope and other data functionality (such as providing a list of the selected files).
* @author John Thompson, Greenstone Digital Libraries, University of Waikato
* @version 2.3b
*/
public class EnrichPane
    extends JPanel
    implements ActionListener, ListSelectionListener, TreeSelectionListener, MSMListener {

    static private Dimension BUTTON_SIZE = new Dimension(190, 25);
    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;
    /** The name of the panel containing the metadata table. */
    static final private String CARD_ONE  = "Card One";
    /** The name of the panel containing the 'no file' placeholder for the metadata table. */
    static final private String CARD_TWO = "Card Two";
    /** The name of the panel containing the 'no metadata' placeholder for the metadata table. */
    static final private String CARD_ZERO = "Card Zero";
    /** The name of the panel containing the placeholder for the value tree. */
    static final private String TOOLS_OFF = "Tools Off";
    /** The name of the panel containing the value tree. */
    static final private String TOOLS_ON  = "Tools On";

    /** The GValueTree graphically shows the available metadata that has been previously assigned, and provides controls for adding, updating and removing metadata, depending on the users selections in the other important components. */
    private GValueTree tree = null;
    /** The layout manager used to display either the GTable (when records are selected) or a placeholder panel with the immortal words 'No Record Selected'. */
    private CardLayout card_layout = null;
    /** The layout manager used to display either the GValueTree (when records are selected) or a placeholder panel with the immortal words 'No Record Selected'. */
    private CardLayout card_layout2 = null;
    /** 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 filter = null;
    /** The data model behind the GTable, to which we hold a reference for convenient access. */
    private GTableModel model = null;
    /** The currently reported selection. Note that this may actually be incorrect, but if so the changed flag will be set, and the selection will be updated the next time it is needed. */
    private FileNode records[] = 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 update;
    /** 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;
    /** A reference to the metadata table, via its superclass. */
    private JTable table;
    /** 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 DragTree collection_tree;
    /** The currently selected metadata determined by listening to every second list selection event from the metadata table. */
    private Metadata selected_metadata;
    /** Provide synchronization between the collection trees in this view and the collection pane view. */
    private TreeSynchronizer tree_sync = null;

    /** Constructor.
     * @param tree_sync The <strong>TreeSynchronizer</strong> to be used on the collection tree
     * @see org.greenstone.gatherer.Configuration
     * @see org.greenstone.gatherer.gui.EnrichPane.GValueTree
     */
    public EnrichPane(TreeSynchronizer tree_sync)
    {
    this.tree = null;
    this.tree_sync = tree_sync;

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

    update = new GLIButton();
    update.addActionListener(this);
    update.setEnabled(false);
    update.setMnemonic(KeyEvent.VK_P);
    update.setPreferredSize(BUTTON_SIZE);
    Dictionary.registerBoth(update, "MetaEdit.Overwrite", "MetaEdit.Overwrite_Tooltip");

    remove = new GLIButton();
    remove.addActionListener(this);
    remove.setEnabled(false);
    remove.setMnemonic(KeyEvent.VK_R);
    remove.setPreferredSize(BUTTON_SIZE);
    Dictionary.registerBoth(remove, "MetaEdit.Remove", "MetaEdit.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, "MetaEdit.Expand", "MetaEdit.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, "MetaEdit.Expand", "MetaEdit.Expand_Tooltip");

    tree = new GValueTree(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.
     * @see org.greenstone.gatherer.collection.CollectionManager
     * @see org.greenstone.gatherer.gui.EnrichPane.GValueTree
     * @see org.greenstone.gatherer.gui.table.GTableModel
     * @see org.greenstone.gatherer.msm.ElementWrapper
     * @see org.greenstone.gatherer.msm.MetadataSetManager
     * @see org.greenstone.gatherer.msm.MSMEvent
     */
    public void actionPerformed(ActionEvent event) {
    Object esrc = event.getSource();
    if (esrc == add) {
        ElementWrapper element = tree.getSelectedMetadataElement();
        String value = tree.getSelectedValue();
        (new AppendMetadataTask(element, value)).start();
        value = null;
        element = null;
    }
    else if (esrc == update) {
        ElementWrapper element = tree.getSelectedMetadataElement();
        String value = tree.getSelectedValue();
        (new UpdateMetadataTask(element, value)).start();
        value = null;
        element = null;
    }
    else if (esrc == remove) {
        (new RemoveMetadataTask()).start();
    }
    else if (esrc == expand) {
        EditorDialog ed = new EditorDialog();
        String temp = ed.display(tree.getSelectedValue());
        if (temp != null) {
        tree.setSelectedValue(temp);
        }
    }
    else if (esrc == expand_for_extracted) {
        EditorDialog ed = new EditorDialog();
        ed.setEditable(false);
        String temp = ed.display(selected_metadata.getValue());
    }
    validateControls();
    }

    private class AppendMetadataTask
    extends Thread {

    private ElementWrapper element = null;
    private String value = null;

    private AppendMetadataTask(ElementWrapper element, String raw_value) {
        this.element = element;
        this.value = raw_value;
        // Transform the raw text to be GREENSTONE and DOM compatible - as that will be its next destination immediately after being added to the value model
        //this.value = /odec.transform(value, /odec.ENCODE_PATH);
        //this.value = /odec.transform(this.value, /odec.REMOVE_SQUARE_BRACKET);
        //this.value = /odec.transform(this.value, /odec.TEXT_TO_DOM);
    }

    public void run() {
        // System.err.println("Add metadata - '" + value + "'");
        // Check the new metadata is valid
        if (records != null && element != null && value != null) {
        // Check the records, and if they are folders then display the warning.
        Metadata added_metadata = null;
        if (!records[0].isLeaf()) {
            WarningDialog dialog = new WarningDialog("warning.DirectoryLevelMetadata", true);
            if (dialog.display() == JOptionPane.OK_OPTION) {
            added_metadata = Gatherer.c_man.getCollection().msm.addMetadata(System.currentTimeMillis(), records, element, value);
            }
            dialog.dispose();
            dialog = null;
        }
        else {
            added_metadata = Gatherer.c_man.getCollection().msm.addMetadata(System.currentTimeMillis(), records, element, value);
        }
        model.selectMetadataWhenBuildingComplete(added_metadata);
        }
    }
    }

    private class UpdateMetadataTask
    extends Thread {

    private ElementWrapper element;
    private String value;

    private UpdateMetadataTask(ElementWrapper element, String raw_value) {
        this.element = element;
        this.value = raw_value;
        // Transform the raw text to be DOM compatible - as that will be its next destination immediately after being added to the value model
        //this.value = /odec.transform(value, /odec.REMOVE_SQUARE_BRACKET);
        //this.value = /odec.transform(this.value, /odec.TEXT_TO_DOM);
    }

    public void run() {
        // You can only update if there is a selected_metadata and
        // you have valid values in all fields.
        Gatherer.println("Replacing value:");
        if (selected_metadata != null && records != null && element != null && value != null) {
        selected_metadata = Gatherer.c_man.getCollection().msm.updateMetadata(System.currentTimeMillis(), selected_metadata, records, value, MetaEditPrompt.CONFIRM, selected_metadata.isFileLevel());
        }
        model.selectMetadataWhenBuildingComplete(selected_metadata);
    }
    }

    private class RemoveMetadataTask
    extends Thread {

    private RemoveMetadataTask() {}

    public void run() {
        Gatherer.println("Removing value:");
        if (selected_metadata != null && records != null) {
        Gatherer.c_man.getCollection().msm.removeMetadata(System.currentTimeMillis(), selected_metadata, records);
        }

        // Select the closest piece of metadata with the same element name
        model.selectClosestMetadataWhenBuildingComplete(selected_metadata);
    }
    }

    /** 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.
     * @see org.greenstone.gatherer.gui.table.GTableModel
     */
    public void afterDisplay() {
    external_split.setDividerLocation(0.3);
    }
    /** Called whenever a significant change has occured in the state of the currently loaded collection.
     * @param ready <i>true</i> if there is a collection currently ready to be editing, <i>false</i> otherwise.
     * @see org.greenstone.gatherer.collection.CollectionManager
     * @see org.greenstone.gatherer.util.TreeSynchronizer
     */
    public void collectionChanged(boolean ready) {
    if (ready) {
        TreeModel collection_model = Gatherer.c_man.getRecordSet();
        //String[] args = new String[1];
        //args[0] = Gatherer.c_man.getCollection().getName();
        Dictionary.registerText(collection_label, "Collection.Collection");
        // Update label coloring.
        collection_label.setBackground(Configuration.getColor("coloring.collection_heading_background", false));
        collection_label.setForeground(Configuration.getColor("coloring.collection_heading_foreground", false));
        collection_tree.setModel(collection_model);
        // Update tree coloring.
        collection_tree.setBackground(Configuration.getColor("coloring.collection_tree_background", false));
        collection_tree.setForeground(Configuration.getColor("coloring.collection_tree_foreground", false));
        // Register our msm dependant components (or correctly their models) with msm.
        if (model != null) {
        // remove the listener first - in case its already present
        Gatherer.c_man.getCollection().msm.removeMSMListener(model);
        Gatherer.c_man.getCollection().msm.addMSMListener(model);
        }
        // register the pane itself as an MSMListener, so if we add a new metadata set, it will immediately show up. - remove itself first just in case
        Gatherer.c_man.getCollection().msm.removeMSMListener(this);
        Gatherer.c_man.getCollection().msm.addMSMListener(this);

        // Clear the currently selected metadata element in the table
        // This is important so the value tree is refreshed when the collection changes
        tree.setSelectedMetadataElement(null);
    }
    else {
        Dictionary.registerText(collection_label, "Collection.No_Collection");
        collection_label.setBackground(Color.lightGray);
        collection_label.setForeground(Color.black);
        collection_tree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode(Dictionary.get("Collection.No_Collection"))));
    }

    filter.setEnabled(ready);
    // Ensure that this collection tree view is synchronized with any others.
    tree_sync.add(collection_tree);
    }
    /** Used to create, connect and layout the components to be shown on this control panel.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.collection.CollectionManager
     * @see org.greenstone.gatherer.file.FileOpenActionListener
     * @see org.greenstone.gatherer.gui.Filter
     * @see org.greenstone.gatherer.gui.GComboBox
     * @see org.greenstone.gatherer.gui.table.GTableModel
     */
    public void display() {
    RightButtonListener right_button_listener = new RightButtonListener();
    // 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);

    ///atherer.println("\tCreating collection_label");
    collection_label = new JLabel();
    Dictionary.registerText(collection_label, "Collection.No_Collection");
    collection_label.setOpaque(true);

    DragGroup group = new DragGroup();
    TreeModel collection_model = Gatherer.c_man.getRecordSet();
    if (collection_model != null) {
        collection_tree = new DragTree("MetaEdit", collection_model, null, false);
    }
    else {
        collection_tree = new DragTree("MetaEdit", null, 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(right_button_listener);
    collection_tree.addTreeSelectionListener(this);
    collection_tree.addTreeExpansionListener(Gatherer.g_man.foa_listener);
    collection_tree.setLargeModel(true);
    collection_tree.setRootVisible(false);
    
    KeyListenerImpl key_listener = new KeyListenerImpl();
    collection_tree.addKeyListener(key_listener);
    JScrollPane collection_scroll = new JScrollPane(collection_tree);

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

    // Connection

    // 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(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, "MetaEdit.No_File");

    card_layout = new CardLayout();

    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, "MetaEdit.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, "MetaEdit.No_Metadata");

    JPanel table_pane_one = new JPanel();

    ///atherer.println("\tCreating metadata_table");
    table = new JTable();
    model = new GTableModel(table);
    table.setModel(model);
    table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    table.getSelectionModel().addListSelectionListener(this);
    table.setColumnSelectionAllowed(false);

    // 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 = table.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@")) {
        table.removeMouseListener(mls[i]);
        }
    }
    // Add the slightly-altered mouse listener
    table.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 (15 -> 2 pixels high).
    JTableHeader table_header = table.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);
    }

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

    // Control pane
    ///atherer.println("\tCreating Metadata Controls");

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

    card_layout2 = new CardLayout();

    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, "MetaEdit.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(tree, BorderLayout.CENTER);

    control_pane.setLayout(card_layout2);
    control_pane.add(tools_off_pane, TOOLS_OFF);
    control_pane.add(tools_on_pane, TOOLS_ON);

    // 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_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(card_layout);
    table_card_pane.add(table_pane_zero, CARD_ZERO);
    table_card_pane.add(table_pane_one, CARD_ONE);
    table_card_pane.add(table_pane_two, CARD_TWO);

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

    /** Method that is called whenever an element within a set is changed or modified. - needed for MSMListener
     * @param event A <strong>MSMEvent</strong> containing details of the event that caused this message to be fired.
     */
    public void elementChanged(MSMEvent event) {}

    /** Ensures a certain tree path is expanded, visible and selected within the collection tree.
     * @param path The <strong>TreePath</strong> to make visible.
     * @see org.greenstone.gatherer.gui.tree.DragTree
     */
    private void expandPath(TreePath path) {
    collection_tree.expandPath(path);
    collection_tree.setSelectionPath(path);
    }
    /** Called to inform this control panel that it has just gained focus as an effect of the user clicking on its tab.
     * @see org.greenstone.gatherer.gui.tree.DragTree
     */
    public void gainFocus() {
    // Use this opportunity to update the table model etc.
    // Select the first file (if any)
    if (collection_tree != null && collection_tree.getRowCount() > 0) {
        collection_tree.setImmediate(true);
        collection_tree.setSelectionRow(0);
        collection_tree.setImmediate(false);
    }
    else {
        // No selection. Reset other components
        valueChanged(new TreeSelectionEvent(this, null, false, null, null));
    }

    // Update the menubars idea of whats been selected
    if (collection_tree != null) {
        if (collection_tree.isSelectionEmpty()) {
        Gatherer.g_man.menu_bar.setMetaAuditSuffix(null);
        }
        else {
        Gatherer.g_man.menu_bar.setMetaAuditSuffix(collection_tree.getSelectionDetails());
        }
    }
    // Update the meta-audit view to show the current selection, if any.
    Gatherer.g_man.meta_audit.setRecords(records);
    }

    /** Retrieve the currently selected records.
     * @return A <strong>FileNode[]</strong> containing the current, and up to date, selection.
     */
    public FileNode[] getSelectedNode() {
    return records;
    }

    /** Called whenever the metadata value changes in some way, such as the addition of a new value. - needed for MSMListener
     * @param event A <strong>MSMEvent</strong> containing details of the event that caused this message to be fired.
     */
    public void metadataChanged(MSMEvent event) {}

    /** 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) {
    filter.setEditable(mode > Configuration.LIBRARIAN_MODE);
    }

    /** Method that is called whenever the metadata set collection changes in some way, such as the addition of a new set or the merging of two sets. - needed for MSMListener
     * @param event A <strong>MSMEvent</strong> containing details of the event that caused this message to be fired.
     */
    public void setChanged(MSMEvent event){
    // call the collection tree value changed - we need to do the same stuff here
    valueChanged((TreeSelectionEvent) null);
    }

    /** This method enables or diables the various controls based upon the state of the system. This method should be called after every change which could affect the GUI.
     */
    private void validateControls() {
    validateControls(false);
    }

    private void validateControls(boolean update_card) {
    validateMetadataTable();
    // Validate card_layout_2
    // We only ever change tools if the metadata table has finished building or is empty.
    if (update_card) {
        if (selected_metadata == null && model.isBuildingComplete() && model.getRowCount() == 0) {
        card_layout2.show(control_pane, TOOLS_OFF);
        }
        else {
        card_layout2.show(control_pane, TOOLS_ON);
        }
    }

    // Validate the buttons in the lower pane
    if (selected_metadata == null) {
        // Nothing selected
        return;
    }

    // Does the metadata element have no current value?
    GValueNode value_node = selected_metadata.getValueNode();
    if (value_node == null) {
        // Can only append if something has been entered
        add.setEnabled((tree.getSelectedValue().length() > 0));
        // Nothing to replace or remove
        update.setEnabled(false);
        remove.setEnabled(false);
    }

    else {
        // Check if the text in the value field is the same as the metadata value
        if (tree.getSelectedValue().equals(value_node.getFullPath(false))) {
        // Can't replace
        update.setEnabled(false);
        // Adding, however, is dependant on whether the metadata is common or uncommon. If the later then you can append so as to make it common.
        add.setEnabled(!model.isCommon(selected_metadata));
        }
        else {
        // Can append or replace, if something has been entered
        add.setEnabled((tree.getSelectedValue().length() > 0));
        update.setEnabled((tree.getSelectedValue().length() > 0));
        }

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

    /** Validate the metadata table area, and if no metadata is available display the no metadata panel. */
    public void validateMetadataTable() {
    // Validate card_layout
    if (records == null) {
        card_layout.show(table_card_pane, CARD_ZERO);
    } else if (model.getRowCount() == 0) {
        card_layout.show(table_card_pane, CARD_TWO);
    } else {
        card_layout.show(table_card_pane, CARD_ONE);
    }
    }

    /** Another in a long list of listeners, this one is called whenever the
     * selection within the JTable changes. When it does we load the new data
     * and set the selected_metadata if applicable (ie the metadata is non-
     * empty).
     * @param event The <strong>ListSelectionEvent</strong> which contains all the information about the event that has been fired.
     * @see org.greenstone.gatherer.gui.table.GTableModel
     * @see org.greenstone.gatherer.gui.EnrichPane.GValueTree
     */
    public void valueChanged(ListSelectionEvent event) {
    // We only want to handle one event per selection, so wait for the value to stabilise
    ListSelectionModel lsm = table.getSelectionModel();
    if (lsm.getValueIsAdjusting() == false) {
        // We have a SINGLE_SELECTION model set so there is at most one
        // selection. Get the offending row.
        int selected = table.getSelectedRow();
        selected_metadata = model.getMetadataAtRow(selected);
        if (selected_metadata != null) { // Check something is selected.
        tree.setSelectedMetadataElement(selected_metadata.getElement());
        GValueNode value_node = selected_metadata.getValueNode();
        if (value_node != null) {
            tree.setSelectedValue(value_node.getFullPath(true));
        }
        else {
            tree.setSelectedValue("");
        }
        }
        validateControls(true);
    }
    }

    /** Called whenever the value tree of an metadata element changes in some way, such as the addition of a new value. - needed for MSMListener
     * @param event A <strong>MSMEvent</strong> containing details of the event that caused this message to be fired.
     */
    public void valueChanged(MSMEvent event) {}

    /** This method is called whenever the selection within the collection
     * tree changes. This causes the table to be rebuilt with a new model
     * @param event A <strong>TreeSelectionEvent</strong> containing information about the event.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.file.FileNode
     * @see org.greenstone.gatherer.gui.GUIManager
     * @see org.greenstone.gatherer.gui.MenuBar
     * @see org.greenstone.gatherer.gui.table.GTableModel
     * @see org.greenstone.gatherer.msm.MetadataSetManager
     * @see org.greenstone.gatherer.gui.tree.DragTree
     * @see org.greenstone.gatherer.util.ArrayTools
     */
    public void valueChanged(TreeSelectionEvent event) {
    ///ystem.err.println("\n(MEP) valueChanged(TreeSelectionEvent)...");

    // Don't bother if this isn't the selected view
    // if (Gatherer.g_man.getSelectedView() != this) {
    //     return;
    // }

    if (collection_tree.getSelectionCount() > 0) {
        records = null;
        TreePath paths[] = collection_tree.getSelectionPaths();
        for (int i = 0; i < paths.length; i++) {
        FileNode record = (FileNode) paths[i].getLastPathComponent();
        records = ArrayTools.add(records, record);
        }

        // Remember the previous selection so we can select it again later
        Metadata previous_selection = selected_metadata;

        table_label.setText(collection_tree.getSelectionDetails());

        // Remove old model from msm
        Gatherer.c_man.getCollection().msm.removeMSMListener(model);
        // Create new model
        model = new GTableModel(table, records);
        table.setModel(model);

        // Select the closest piece of metadata in the new file
        model.selectClosestMetadataWhenBuildingComplete(previous_selection);
    }
    else {
        records = null;
        Dictionary.registerText(table_label, "MetaEdit.No_File");

        // Remove old model from msm
        if (Gatherer.c_man.ready()) {
        Gatherer.c_man.getCollection().msm.removeMSMListener(model);
        }
        // Create new model
        model = new GTableModel(table);
        table.setModel(model);
    }

    if (table != null) {
        table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
        Dimension table_size = table.getPreferredSize();
        TableColumnModel column_model = table.getColumnModel();

        TableColumn inherited_column = column_model.getColumn(0);
        inherited_column.setPreferredWidth(20);
        inherited_column.setCellRenderer(new TableCellRenderer(model));

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

        TableColumn value_column = column_model.getColumn(2);
        value_column.setPreferredWidth(((3 * TABLE_SIZE.width) / 4) - 30);
        value_column.setCellRenderer(new TableCellRenderer(model));
    }
    table.doLayout();
    validateControls();
    }


    /** 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 = table.getEditorComponent();
            Point p = e.getPoint();
            Point p2 = SwingUtilities.convertPoint(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 || !table.isEditing()) {
                return false;
            }
            MouseEvent e2 = SwingUtilities.convertMouseEvent(table, e, dispatchComponent);
            dispatchComponent.dispatchEvent(e2);
            return true;
        }

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

    private boolean shouldIgnore(MouseEvent e) {
        return e.isConsumed() || (!(SwingUtilities.isLeftMouseButton(e) && table.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 = table.rowAtPoint(p);
            int column = table.columnAtPoint(p);
        // The autoscroller can generate drag events outside the Table's range.
            if ((column == -1) || (row == -1)) {
                return;
            }

            if (table.editCellAt(row, column, e)) {
                setDispatchComponent(e);
                repostEvent(e);
            }
        else if (table.isRequestFocusEnabled()) {
                table.requestFocus();
        }

            CellEditor editor = table.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 = model.getMetadataAtRow(row);

            // If this metadata is inherited, switch to the folder it came from
            if (!selected_metadata.isFileLevel()) {
            File folder_inherited_from = selected_metadata.getFile();
            if (folder_inherited_from != null) {
                collection_tree.setSelection(folder_inherited_from);
            }
            }

            table.changeSelection(row, 0, e.isControlDown(), e.isShiftDown());
        }
        else {
            table.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 = table.getCellEditor();
            if (editor == null || editor.shouldSelectCell(e)) {
                Point p = e.getPoint();
                int row = table.rowAtPoint(p);
                int column = table.columnAtPoint(p);
            // The autoscroller can generate drag events outside the Table's range.
                if ((column == -1) || (row == -1)) {
                    return;
                }
            table.changeSelection(row, column, false, 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 FileNode 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;

        // Get the paths currently selected in the tree
        selection_paths = tree.getSelectionPaths();

        // 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;
        }

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

        // Always have meta-audit option
        String[] args = new String[1];
        args[0] = collection_tree.getSelectionDetails();
        metaaudit = new JMenuItem(Dictionary.get("Menu.Metadata_View", args), 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 = (FileNode) 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());
        }
    }
    }


    /** 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 = ((FileNode)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 = ((FileNode)path.getLastPathComponent()).getFile();
        if(file == null) return;
        
        if (file.isDirectory() && tree.isCollapsed(path)) {
            vk_left_pressed = 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 "Enter" 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 GValueTree
    extends JPanel
    implements TreeSelectionListener {
    private boolean ignore_tree_selection_event = false;
    private boolean manual_text_edit_event;
    private CardLayout card_layout;
    private String card_showing = null;
    /** The metadata element that is currently selected. */
    private ElementWrapper selected_metadata_element = null;
    private GValueModel vm;
    private JTextArea extracted_message;
    private JTextField value;
    private JTree tree;

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


    public GValueTree(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, "MetaEdit.Value");

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

        JPanel button_pane = new JPanel();

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

        tree = new JTree(new GValueModel());
        tree.addTreeSelectionListener(this);
        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(value, BorderLayout.CENTER);

        button_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
        button_pane.setLayout(new GridLayout());
        button_pane.add(add);
        button_pane.add(update);
        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;
    }


    public GValueModel getModel() {
        return (GValueModel) tree.getModel();
    }


    public ElementWrapper getSelectedMetadataElement() {
        return selected_metadata_element;
    }


    public String getSelectedValue() {
        String raw_value = value.getText();
        raw_value = Codec.transformUnicode(raw_value);
        raw_value = Codec.transform(raw_value, Codec.ENCODE_PATH);
        raw_value = Codec.transform(raw_value, Codec.ENCODE_SQUARE_BRACKETS);
        return raw_value;
    }


    public void setSelectedMetadataElement(ElementWrapper element)
    {
        ///ystem.err.println("Setting selected metadata element to: " + element);
        if (element == null) {
        selected_metadata_element = null;
        return;
        }

        // Don't bother if the element selected is the same as the current one
        if (selected_metadata_element != null && element.equals(selected_metadata_element)) {
        return;
        }

        if (vm != null) {
        // Close any expanded paths in the tree
        GValueNode root_node = (GValueNode) vm.getRoot();
        for (int i = 0; i < root_node.getChildCount(); i++) {
            GValueNode child_node = (GValueNode) root_node.getChildAt(i);
            TreePath child_path = new TreePath(child_node.getPath());
            if (tree.isExpanded(child_path)) {
            tree.collapsePath(child_path);
            }
        }
        }

        // Load the model for the newly selected metadata element
        selected_metadata_element = element;
        if (Gatherer.c_man != null && Gatherer.c_man.getCollection() != null && Gatherer.c_man.getCollection().msm != null && tree != null) {
        vm = Gatherer.c_man.getCollection().msm.getValueTree(element);
        tree.setModel(vm);
        }

        // 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.toString();
        Dictionary.registerText(extracted_message, "MetaEdit.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;
        }
    }


    /** Handles TreeSelectionEvents. */
    public void valueChanged(TreeSelectionEvent event)
    {
        if (tree.getSelectionCount() != 0 && !ignore_tree_selection_event) {
        TreePath path = tree.getSelectionPath();
        GValueNode node = (GValueNode) path.getLastPathComponent();
        setSelectedValue(node.getFullPath(true));
        }
    }


    /** Sets the value in the text field. */
    public void setSelectedValue(String val)
    {
        // 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)) {
        // Decode val
        ///ystem.err.println("Before transforms: " + val);
        //val = Codec.transform(val, Codec.DECODE_SQUARE_BRACKETS);
        //val = Codec.transform(val, Codec.DECODE_PATH);
        ///ystem.err.println("Setting selected value to: " + val);
        manual_text_edit_event = val.equals("");  // Set to false unless val == ""
        value.setText(val); ///odec.transform(val, /odec.GREENSTONE_TO_TEXT));
        value.setCaretPosition(0);
        manual_text_edit_event = true;
        }
    }


    /** Returns a TreePath for the node most closely matching the metadata value. */
    private TreePath getClosestPath(String val)
    {
        ///ystem.err.println("Select closest path to: " + val);
        // Start at the root of the tree
        GValueNode tree_node = (GValueNode) tree.getModel().getRoot();

        // Hierarchical values are separated using '|'
        PatternTokenizer tokenizer = new PatternTokenizer(val, StaticStrings.PIPE_STR);
        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++) {
            GValueNode child_node = (GValueNode) tree_node.getChildAt(i);
            if (child_node.toString(GValueNode.DOM).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++) {
            GValueNode child_node = (GValueNode) tree_node.getChildAt(i);
            if (child_node.toString(GValueNode.DOM).startsWith(token)) {
                // 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());
    }


    /** 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);
        }
        }
    }


    private class MetadataFieldListener
        implements KeyListener {

        /** Gives notification of key events on the text field */
        public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_TAB) {
            // Tab: Auto-complete
            if (tree.getSelectionCount() != 0 && !getSelectedValue().equals("")) {
            TreePath path = tree.getSelectionPath();
            GValueNode node = (GValueNode) path.getLastPathComponent();
            String val = node.getFullPath(true);
            ///ystem.err.println("Setting value to: " + val);
            value.setText(val);
            val = null;
            }
        }
        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
            // Enter: Append the metadata value, if we're allowed to
            if (add.isEnabled()) {
            add.doClick();
            }
        }
        }

        public void keyReleased(KeyEvent e) { }

        public void keyTyped(KeyEvent e) { }
    }


    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(); ///odec.transform(getSelectedValue(), /odec.TEXT_TO_DOM);
        ///ystem.err.println("\n(Validate) Value text: " + value_text);

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

            ///ystem.err.println("The closest path is: " + closest_path);

            // 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("\\") && !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
            validateControls(); // Don't update the tools view itself
        }
        }
    }
    }
}