source: trunk/gli/src/org/greenstone/gatherer/cdm/ArgumentConfiguration.java@ 5907

/**
 *#########################################################################
 *
 * 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.
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.cdm;

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.cdm.Argument;
import org.greenstone.gatherer.cdm.ArgumentContainer;
import org.greenstone.gatherer.cdm.Classifier;
import org.greenstone.gatherer.cdm.CollectionDesignManager;
import org.greenstone.gatherer.cdm.PlugIn;
import org.greenstone.gatherer.gui.ModalDialog;
import org.greenstone.gatherer.gui.SimpleMenuBar;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.greenstone.gatherer.valuetree.GValueModel;

/** This class provides us with a dialog box which allows us to edit the arguments of either a PlugIn or a Classifier.
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 * @see org.greenstone.gatherer.cdm.Classifier
 * @see org.greenstone.gatherer.cdm.PlugIn
 */
public class ArgumentConfiguration
    extends ModalDialog
    implements ActionListener {
    /** The data whose arguments we are editing. */
    private ArgumentContainer data = null;
    /** Argument these argument controls coloured or uncoloured (alternates to indicate inheritance). */
    private boolean coloured = false;
    /** Whether we have successfully edited the arguments associated with the ArgumentContainer or if we have failed to enter required arguments and have instead cancelled (which would cause argument additions to roll back). */
    private boolean success = false;
    /** A button to cancel this dialog. */
    private JButton cancel = null;
    /** A button to accept the changes and close the dialog. */
    private JButton ok = null;
    /** A reference to the ourselves so our inner classes can dispose us like a dialog. */
    private ArgumentConfiguration self = null;
    /** The central pane where a list of known arguments is displayed. */
    private JPanel central_pane = null;
    /** The field for entering custom arguments. */
    private JTextField custom = null;
    /** The name of the owner of the last argument control. */
    private String previous_owner = null;
    /** The size used for an argument label. */
    static final private Dimension LABEL_SIZE = new Dimension(225, 25);
    /** Size of a list. */
    static final private Dimension LIST_SIZE = new Dimension(380, 50);
    /** The size used for the dialog. */
    static final private Dimension SIZE = new Dimension(800, 425);

    /** Constructor.
     * @param data The plugin or classifier whose arguments we are configuring, in the form of its supported <strong>ArgumentContainer</strong> interface.
     * @see org.greenstone.gatherer.Configuration
     */
    public ArgumentConfiguration(ArgumentContainer data) {
    super(Gatherer.g_man);
    this.data = data;
    this.self = this;

    // Create
    setModal(true);
    setSize(SIZE);
    setJMenuBar(new SimpleMenuBar("designingacollection")); // can we tell whether we are doing a classifier or plugin, to make the help more specific??
    Dictionary.setText(this, "CDM.ArgumentConfiguration.Title");

    central_pane = new JPanel();
    JPanel content_pane = (JPanel) getContentPane();

    JPanel custom_pane = new JPanel();
    String custom_str = data.getCustom();
    if (custom_str != null) {
        custom = new JTextField(custom_str);
    }
    else {
        custom = new JTextField();
    }
    JLabel custom_label = new JLabel();
    custom_label.setPreferredSize(LABEL_SIZE);
    Dictionary.setText(custom_label, "CDM.ArgumentConfiguration.Custom");

    JPanel header_pane = new JPanel();
    JLabel header = new JLabel();
    header.setHorizontalAlignment(JLabel.CENTER);
    header.setOpaque(true);
    String args[] = new String[1];
    args[0] = data.getName();
    Dictionary.setText(header, "CDM.ArgumentConfiguration.Header", args);

    JPanel button_pane = new JPanel();
    cancel = new JButton();
    cancel.setMnemonic(KeyEvent.VK_C);
    Dictionary.setBoth(cancel, "General.Cancel", "General.Pure_Cancel_Tooltip");
    ok = new JButton();
    ok.setMnemonic(KeyEvent.VK_O);
    Dictionary.setBoth(ok, "General.OK", "General.OK_Tooltip");

    // Listeners
    cancel.addActionListener(this);
    ok.addActionListener(this);

    // Layout
    custom_pane.setLayout(new BorderLayout());
    custom_pane.add(custom_label, BorderLayout.WEST);
    custom_pane.add(custom, BorderLayout.CENTER);

    header_pane.setBorder(BorderFactory.createEmptyBorder(0,0,5,0));
    header_pane.setLayout(new BorderLayout());
    header_pane.add(header, BorderLayout.NORTH);
    header_pane.add(custom_pane, BorderLayout.CENTER);

    button_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
    button_pane.setLayout(new GridLayout(1,2));
    button_pane.add(ok);
    button_pane.add(cancel);

    central_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
    central_pane.setLayout(new BoxLayout(central_pane, BoxLayout.Y_AXIS));

    content_pane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
    content_pane.setLayout(new BorderLayout());
    content_pane.add(header_pane, BorderLayout.NORTH);
    content_pane.add(new JScrollPane(central_pane), BorderLayout.CENTER);
    content_pane.add(button_pane, BorderLayout.SOUTH);

    // Now generate a set of controls for each of the arguments.
    generateControls();

    // Display on screen.
    Dimension screen_size = Gatherer.config.screen_size;
    setLocation((screen_size.width - SIZE.width) / 2, (screen_size.height - SIZE.height) / 2);
    screen_size = null;
    }

    /** Any implementation of ActionListener must include this method so that we can be informed when an action has occured on one of the controls we are listening to.
     * @param event An <strong>ActionEvent</strong> containing pertinant information about the event that fired this call.
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl
     * @see org.greenstone.gatherer.cdm.ArgumentContainer
     */
    public void actionPerformed(ActionEvent event) {
    boolean cont = true;
    if (event.getSource() == ok) {
        // Update the details stored in the data objects arguments.
        data.setCustom(custom.getText());
        // Loop through each of the controls in the central pane, updating the matching argument as necessary.
        for(int i = 0; i < central_pane.getComponentCount(); i++) {
        Component component = central_pane.getComponent(i);
        if(component instanceof ArgumentControl) {
           cont = cont && ((ArgumentControl)component).updateArgument();
        }
        }
        if(cont) {
        success = true;
        }
    }
    if(cont) {
        dispose();
    }
    }

    /** Destructor. */
    public void destroy() {
    cancel = null;
    central_pane = null;
    custom = null;
    data = null;
    ok = null;
    self = null;
    }

    /** Method which actually forces the dialog to be shown on screen.
     * @return <i>true</i> if the user completed configuration and pressed ok, <i>false</i> otherwise.
     */
    public boolean display() {
    setVisible(true);
    return success;
    }

    private void addHeader(String name, Color color) {
    JPanel header = new JPanel();
    header.setBackground(color);
    JPanel inner_pane = new JPanel();
    inner_pane.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createEmptyBorder(5,5,5,5), BorderFactory.createRaisedBevelBorder()));
    inner_pane.setBackground(color);
    JLabel header_label = new JLabel("<html><strong>" + name + "</strong></html>");
    header_label.setBackground(Gatherer.config.getColor("coloring.collection_heading_background", false));
    header_label.setHorizontalAlignment(JLabel.CENTER);
    header_label.setOpaque(true);

    // Layout
    inner_pane.setLayout(new BorderLayout());
    inner_pane.add(header_label, BorderLayout.CENTER);

    header.setLayout(new BorderLayout());
    header.add(inner_pane, BorderLayout.CENTER);
    central_pane.add(header);
    }

    /** Method to iterate through the arguments associated with whatever argument container we are building an argument control view for, creating the appropriate controls for each.
     * @see org.greenstone.gatherer.cdm.Argument
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl
     */
    private void generateControls() {
    ArrayList arguments = data.getArguments(true, false);
    int total_height = 250;
    for(int i = 0; i < arguments.size(); i++) {
        Argument argument = (Argument) arguments.get(i);
        ArgumentControl argument_control = new ArgumentControl(argument);
        total_height = total_height - argument_control.getPreferredSize().height;
        central_pane.add(argument_control);
    }
    if(total_height > 0) {
        JPanel filler = new JPanel();
        filler.setPreferredSize(new Dimension(100, total_height));
        filler.setSize(new Dimension(100, total_height));
        central_pane.add(filler);
    }
    }

    /** This class encapsulates all the technical difficulty of creating a specific control based on an Argument. */
    private class ArgumentControl
    extends JPanel {
    /** The Argument this control will be based on. */
    private Argument argument = null;

    private Color colour_one = Gatherer.config.getColor("coloring.collection_heading_background", false);
    private Color colour_two = Gatherer.config.getColor("coloring.collection_tree_background", false);
    /** One of a possible two buttons available for adding to this control. */
    private JButton one = null;
    /** The second of two buttons available for adding to this control. */
    private JButton two = null;
    /** A checkbox to allow enabling or diabling of this Argument. */
    private JCheckBox enabled = null;
    /** Some form of editor component, such as a JComboBox or JTextField, used to set parameters to an Argument. */
    private JComponent value = null;
    /** Can be used in place of the other editor components if a list is required. */
    private JList list = null;
    /** Constructor.
     * @param argument The <strong>Argument</strong> this control will be built around.
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.AddListener
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.EnabledListener
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.HierarchyListener
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.ListOption
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.RemoveListener
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.ToolTipUpdater
     */
    public ArgumentControl(Argument argument) {
        this.argument = argument;
        String tip = "<html>" + argument.getDescription() + "</html>";
        tip = Utility.formatHTMLWidth(tip, 60);

        // If this is the first control, there is no history.
        if(previous_owner == null) {
        previous_owner = argument.getOwner();
        addHeader(previous_owner, colour_two);
        }
        // Otherwise if the owner of the control has changed since the last argument, toggle the colouring of the control.
        else if(previous_owner != argument.getOwner()) {
        coloured = !coloured;
        previous_owner = argument.getOwner();
        addHeader(previous_owner, (coloured ? colour_one : colour_two));
        }
        // Create
        if(coloured) {
        setBackground(colour_one);
        }
        else {
        setBackground(colour_two);
        }
        JLabel owner_label = new JLabel(argument.getOwner());
        owner_label.setOpaque(false);
        JLabel label = new JLabel(argument.getName());
        label.setOpaque(false);
        label.setPreferredSize(LABEL_SIZE);
        label.setToolTipText(tip);
        enabled = new JCheckBox(argument.getName());
        enabled.setOpaque(false);
        enabled.setPreferredSize(LABEL_SIZE);
        enabled.setToolTipText(tip);
        JPanel inner_pane = new JPanel();
        inner_pane.setOpaque(false);
        String existing_value = argument.getValue();
        String default_value = argument.getDefaultValue();
        switch(argument.getType()) {
        case Argument.ENUM:
        // Build an option model, wrapping each entry of the list table.
        HashMap arg_list = argument.getOptions();
        ArrayList options_model = new ArrayList();
        Iterator it = arg_list.keySet().iterator();
        while(it.hasNext()) {
            String key = (String) it.next();
            options_model.add(new ListOption(key, (String)arg_list.get(key)));
        }
        Collections.sort(options_model);
        value = new JComboBox(options_model.toArray());
        ((JComboBox)value).setEditable(true);
        ((JComboBox)value).addActionListener(new ToolTipUpdater());
        if(existing_value != null) {
            // Select the correct value. Since they're all text strings we better iterate to be safe.
            selectValue((JComboBox)value, existing_value);
        }
        else if(default_value != null) {
            // Same as above except for default value.
            selectValue((JComboBox)value, default_value);
        }
        break;
        case Argument.FLAG:
        // Only need the check box.
        break;
        case Argument.HIERARCHY:
        value = new JComboBox(Gatherer.c_man.getCollection().msm.getAssignedElements(true));
        /** @TODO - figure out a smarter way of allowing Greenstone extracted metadata to be selected. */
        ((JComboBox)value).setEditable(true);
        ((JComboBox)value).addItemListener(new HierarchyListener());
        // Now ensure we have the existing value or default value selected if either exist.
        if(existing_value != null) {
            selectValue((JComboBox)value, existing_value);
        }
        else if(default_value != null) {
            selectValue((JComboBox)value, default_value);
        }
        break;
        case Argument.INTEGER:
        case Argument.STRING:
        // Use a standard text field
        if(existing_value != null) {
            value = new JTextField(existing_value);
        }
        else {
            if(default_value != null) {
            value = new JTextField(default_value);
            }
            // Special test just for the hfile field.
            else if(argument.getName().equals("hfile")) {
            // Work through previous controls looking for the metadata one.
            for(int i = 0; i < central_pane.getComponentCount(); i++) {
                Object object = central_pane.getComponent(i);
                if(object instanceof ArgumentControl) {
                ArgumentControl control = (ArgumentControl) object;
                if(control.toString().equals("metadata")) {
                    Object temp = control.getValue();
                    if(temp != null) {
                    value = new JTextField(temp.toString() + ".txt");
                    }
                }

                }
            }
            }
            else {
            value = new JTextField();
            }
        }
        break;
        case Argument.LANGUAGE:
        value = new JComboBox(CollectionDesignManager.language_manager.getLanguageCodes().toArray());
        // Now ensure we have the existing value or default value selected if either exist.
        Language selected = null;
        if(existing_value != null) {
            selected = CollectionDesignManager.language_manager.getLanguage(existing_value);
        }
        else if(default_value != null) {
            selected = CollectionDesignManager.language_manager.getLanguage(default_value);
        }
        if(selected != null) {
            ((JComboBox)value).setSelectedItem(selected.getCode());
        }
        break;
        case Argument.METADATUM:
        value = new JComboBox(Gatherer.c_man.getCollection().msm.getAssignedElements());
        /** @TODO - figure out a smarter way of allowing Greenstone extracted metadata to be selected. */
        ((JComboBox)value).setEditable(true);
        // Now ensure we have the existing value or default value selected if either exist.
        if(existing_value != null) {
            selectValue((JComboBox)value, existing_value);
        }
        else if(default_value != null) {
            selectValue((JComboBox)value, default_value);
        }
        break;
        case Argument.METADATA:
        // Comma separated metadata values.
        ArrayList values = argument.getValues();
        value = new JComboBox(Gatherer.c_man.getCollection().msm.getAssignedElements());
        DefaultListModel model = new DefaultListModel();
        list = new JList(model);
        list.setVisibleRowCount(3);
        for(int i = 0; i < values.size(); i++) {
            model.addElement(values.get(i));
        }

        one = new JButton();
        one.addActionListener(new AddListener((JComboBox)value, list));
        Dictionary.setBoth(one, "CDM.ArgumentConfiguration.Add", "CDM.ArgumentConfiguration.Add_Tooltip");
        two = new JButton();
        two.addActionListener(new RemoveListener(list));
        Dictionary.setBoth(two, "CDM.ArgumentConfiguration.Remove", "CDM.ArgumentConfiguration.Remove_Tooltip");

        if(argument.getValues().size() > 0 || argument.isRequired()) {
            enabled.setSelected(true);
            list.setBackground(Color.white);
            list.setEnabled(true);
            one.setEnabled(true);
            two.setEnabled(true);
            value.setEnabled(true);
        }
        else {
            enabled.setSelected(false);
            list.setBackground(Color.lightGray);
            list.setEnabled(false);
            one.setEnabled(false);
            two.setEnabled(false);
            value.setEnabled(false);
        }
        break;
        } // end of switch
        // Enable or disable as necessary.
        if(argument.isRequired() || argument.isAssigned()) {
        enabled.setSelected(true);
        if(value != null) {
            value.setOpaque(true);
            value.setBackground(Color.white);
            value.setEnabled(true);
        }
        }
        else {
        enabled.setSelected(false);
        if(value != null) {
            value.setOpaque(true);
            value.setBackground(Color.lightGray);
            value.setEnabled(false);
        }
        }
        // Listener
        if(value != null && !argument.isRequired()) {
        enabled.addActionListener(new EnabledListener(one, two, list, value));
        }
        // Layout
        if(list == null) {
        enabled.setBorder(BorderFactory.createEmptyBorder(0,0,5,0));
        inner_pane.setLayout(new BorderLayout());
        if(argument.isRequired()) {
            inner_pane.add(label, BorderLayout.WEST);
        }
        else {
            inner_pane.add(enabled, BorderLayout.WEST);
        }
        if(value != null) {
            inner_pane.add(value, BorderLayout.CENTER);
        }
        }
        else {
        JPanel control_pane = new JPanel(new GridLayout(2,1));
        control_pane.add(enabled);
        control_pane.add(value);
        control_pane.setOpaque(false);

        JPanel left_pane = new JPanel(new BorderLayout());
        left_pane.add(control_pane, BorderLayout.CENTER);
        left_pane.add(one, BorderLayout.SOUTH);
        left_pane.setOpaque(false);

        JPanel right_pane = new JPanel(new BorderLayout());
        right_pane.add(new JScrollPane(list), BorderLayout.CENTER);
        right_pane.add(two, BorderLayout.SOUTH);
        right_pane.setOpaque(false);

        inner_pane.setLayout(new GridLayout(1,2));
        inner_pane.add(left_pane);
        inner_pane.add(right_pane);
        }
        setLayout(new BorderLayout());
        //add(owner_label, BorderLayout.NORTH);
        add(inner_pane, BorderLayout.CENTER);
    }

       public Argument getArgument() {
      return argument;
       }

    public Object getValue() {
        if(value instanceof JComboBox) {
        return ((JComboBox)value).getSelectedItem();
        }
        else if(value instanceof JTextField) {
        return ((JTextField)value).getText();
        }
        return null;
    }
    /** Identifies this control by returning the name of the Argument it is based on.
     * @return The name of the Argument as a <strong>String</strong>.
     * @see org.greenstone.gatherer.cdm.Argument
     */
    public String toString() {
        return argument.getName();
    }
    /** Updates the enwrapped Argument using the values provided by the controls.
     * @return <i>true</i> if the update was successful, <i>false</i> otherwise.
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.ListOption
     * @see org.greenstone.gatherer.cdm.Language
     * @see org.greenstone.gatherer.msm.ElementWrapper
     */
    public boolean updateArgument() {
       if(enabled.isSelected() || argument.isRequired()) {
          argument.setAssigned(false);
          String result = null;
          switch(argument.getType()) {
         case Argument.ENUM:
            ListOption option = (ListOption)((JComboBox)value).getSelectedItem();
            if(option != null && option.getValue().length() > 0) {
               argument.setValue(option.getValue());
            }
            else {
            String args[] = new String[1];
            args[0] = argument.getName();
            if(argument.isRequired()) {
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
            }
            // They've left the field blank
            else {
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
                argument.setValue(null);
            }
            args = null;
            return false;
            }
            argument.setAssigned(true);
            return true;
        case Argument.FLAG:
           // Should have already been handled above.
           argument.setAssigned(true);
            return true;
        case Argument.INTEGER:
            result = ((JTextField)value).getText();
            if(result.length() > 0) {
            // Test if the value entered is a valid int.
            try {
                int x = Integer.parseInt(result);
            }
            catch(NumberFormatException nfe) {
                String args[] = new String[2];
                args[0] = argument.getName();
                args[1] = result;
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.Bad_Integer", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
                args = null;
                return false;
            }
            argument.setValue(result);
            }
            else {
            String args[] = new String[1];
            args[0] = argument.getName();
            if(argument.isRequired()) {
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
            }
            // They've left the field blank
            else {
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
                argument.setValue(null);
            }
            args = null;
            return false;
            }
            argument.setAssigned(true);
            return true;
           case Argument.LANGUAGE:
              String language = (((JComboBox)value).getSelectedItem()).toString();
              argument.setValue(language);
              // Kinda lucked out here. Its impossible not to choose an entry from these comboboxes as they are restricted.
              argument.setAssigned(true);
              return true;
        case Argument.METADATUM:
            argument.setValue(((ElementWrapper)((JComboBox)value).getSelectedItem()).getName());
            // Kinda lucked out here. Its impossible not to choose an entry from these comboboxes as they are restricted.
            argument.setAssigned(true);
            return true;
        case Argument.HIERARCHY:
            argument.setValue(((JComboBox)value).getSelectedItem().toString());
            // Kinda lucked out here. Its impossible not to choose an entry from these comboboxes as they are restricted.
            argument.setAssigned(true);
            return true;
        case Argument.METADATA:
            DefaultListModel model = (DefaultListModel)list.getModel();
            ArrayList values = new ArrayList();
            for(int i = 0; i < model.size(); i++) {
            values.add(model.get(i));
            }
            argument.setValues(values);
            argument.setAssigned(true);
            return true;
        case Argument.STRING:
            result = ((JTextField)value).getText();
            if(result.length() > 0) {
            argument.setValue(result);
            }
            else {
            String args[] = new String[1];
            args[0] = argument.getName();
            if(argument.isRequired()) {
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.Required_Argument", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
            }
            // They've left the field blank
            else {
                JOptionPane.showMessageDialog(self, Dictionary.get("CDM.ArgumentConfiguration.No_Value", args), Dictionary.get("CDM.ArgumentConfiguration.Error_Title"), JOptionPane.ERROR_MESSAGE);
                argument.setValue(null);
            }
            args = null;
            return false;
            }
            argument.setAssigned(true);
            return true;
        }
        return false;
        }
        else {
        argument.setAssigned(false);
        return true;
        }
    }
    /** Method to ensure that a certain value is selected, if it exists within that combobox to begin with.
     * @param combobox The <strong>JComboBox</strong> whose selection we are trying to preset.
     * @param target The desired value of the selection as a <strong>String</strong>.
     * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl.ListOption
     * @see org.greenstone.gatherer.msm.ElementWrapper
     */
    public void selectValue(JComboBox combobox, String target) {
        for(int i = 0; i < combobox.getItemCount(); i++) {
        Object object = combobox.getItemAt(i);
        if(object instanceof ListOption) {
            ListOption lo = (ListOption) object;
            if(lo.getValue().equals(target)) {
            combobox.setSelectedIndex(i);
            return;
            }
        }
        else if(object instanceof ElementWrapper) {
            if(object.toString().equals(target)) {
            combobox.setSelectedIndex(i);
            return;
            }
        }
        }
    }
    /** Forces the control into an 'enabled' mode. */
    public void setEnabled() {
        enabled.setSelected(true);
    }
    /** Explicitly sets the value of a JTextField type control to the given String.
     * @param value_str The new value of the control as a <strong>String</strong>.
     */
    public void setValue(String value_str) {
        ((JTextField)value).setText(value_str);
    }
    /** Listener which adds entries to a list from a combobox when fired. */
    private class AddListener
        implements ActionListener {
        /** The model behind the target list. */
        private DefaultListModel model = null;
            /** The source for data to be added to the list. */
        private JComboBox source = null;
        /** The list to add data to. */
        private JList target = null;
        /** Constructor.
         * @param source A <strong>JComboBox</strong> which serves as the source for data.
         * @param target A <strong>JList</strong> which serves as the target for data.
         */
        public AddListener(JComboBox source, JList target) {
        this.model = (DefaultListModel) target.getModel();
        this.source = source;
        this.target = target;
        }
        /** When the add button is clicked, we attempt to add the selected metadata from the source into the target.
         * @param event An <strong>ActionEvent</strong> containing information about the event.
         * @see org.greenstone.gatherer.msm.ElementWrapper
         */
        public void actionPerformed(ActionEvent event) {
        ElementWrapper element = (ElementWrapper) source.getSelectedItem();
        String name = element.toString();
        if(!model.contains(name)) {
            boolean found = false;
            int index = 0;
            while(!found && index < model.size()) {
            String sibling = (String) model.get(index);
            if(name.compareTo(sibling) < 0) {
                model.add(index, name);
                found = true;
            }
            else {
                index++;
            }
            }
            if(!found) {
            model.addElement(name);
            }
        }
        }
    }
    /** Listens for actions apon the enable checkbox, and if detected enables or diables control appropriately. */
    private class EnabledListener
        implements ActionListener {
        /** One of two possible buttons that might have their enabled state changed by this listener. */
        private JButton one = null;
        /** One of two possible buttons that might have their enabled state changed by this listener. */
        private JButton two = null;
        /** An editor component, such as a JComboBox or JTextField, that might have its enabled state changed by this listener. */
        private JComponent target = null;
        /** A list which might have its enabled state changed by this listener. */
        private JList list = null;
        /** Constructor.
         * @param one A <strong>JButton</strong> whose enabled state is determined by the listener, or <i>null</i> if no button.
         * @param two A <strong>JButton</strong> whose enabled state is determined by the listener, or <i>null</i> if no button.
         * @param list A <strong>JList</strong> whose enabled state is determined by the listener, or <i>null</i> if no list.
         * @param list A <strong>JComponent</strong> whose enabled state is determined by the listener, or <i>null</i> if no component.
         */
        public EnabledListener(JButton one, JButton two, JList list, JComponent target) {
        this.list = list;
        this.one = one;
        this.target = target;
        this.two = two;
        }
        /** Any implementation of ActionListener must include this method so that we can be informed when an action has been performed on or registered check box, prompting us to change the state of the other controls as per the users request.
         * @param event An <strong>ActionEvent</strong> containing information about the click.
         */
        public void actionPerformed(ActionEvent event) {
        JCheckBox source = (JCheckBox)event.getSource();
        if(source.isSelected()) {
            target.setBackground(Color.white);
            target.setEnabled(true);
            if(one != null && two != null && list != null) {
            one.setEnabled(true);
            two.setEnabled(true);
            list.setBackground(Color.white);
            list.setEnabled(true);
            }
        }
        else {
            target.setBackground(Color.lightGray);
            target.setEnabled(false);
            if(one != null && two != null && list != null) {
            one.setEnabled(false);
            two.setEnabled(false);
            list.setBackground(Color.lightGray);
            list.setEnabled(false);
            }
        }
        }
    }
    /** If a metadata element is selected that requires an hfile, then this listener defaults that hfile. */
    private class HierarchyListener
        implements ItemListener {
        /** Any implementation of ItemListener must include this method so that we can be informed when an item from the list is selected, and generate a predetermined hfile for that selection.
         * @param event An <strong>ItemEvent</strong> containing information about the selection.
         * @see org.greenstone.gatherer.cdm.ArgumentConfiguration.ArgumentControl
         * @see org.greenstone.gatherer.valuetree.GValueModel
         */
        public void itemStateChanged(ItemEvent event) {
        // Determine if the selected element represents a hierarchy.
        Object temp = ((JComboBox)value).getSelectedItem();
        String filename = temp.toString();
        // Search for a argument control called hfile and enable and set value.
        for(int i = 0; i < central_pane.getComponentCount(); i++) {
            Object object = central_pane.getComponent(i);
            if(object instanceof ArgumentControl) {
            ArgumentControl control = (ArgumentControl) object;
            if(control.toString().equals("hfile")) {
                control.setValue(filename + ".txt");
                control.setEnabled(true);
            }
            }
        }
        }
    }
    /** A ListOption is a compound item which is constructed from several Strings. That magic part is that the length of screen real-estate used by the text version of this item is limited. */
    private class ListOption
        implements Comparable {
        /** The maximum length of this String version of this item. */
        private int MAX_DESC = 65;
        /** The description of the value for this item. */
        private String description = null;
        /** A cached value for the text value of this option, as it never changes after the first call to toString(). */
        private String text = null;
        /** The value for this item. */
        private String value = null;
        /** Constructor.
         * @param value The value for this item as a <strong>String</strong>.
         * @param description The description of the value as a <strong>String</strong>.
         */
        public ListOption(String value, String description) {
        this.description = description;
        this.value = value;
        }
        /** Compare two possible ListOption objects for ordering.
         * @param object The <strong>Object</strong> to compare to.
         * @return An <i>int</i> indicating order as explained in String.
         * @see java.lang.String#compareTo
         */
        public int compareTo(Object object) {
        return toString().compareTo(object.toString());
        }
        /** Tests two possible ListOption objects for equality. Uses the result from compareTo().
         * @param The <strong>Object</strong> which may be equal.
         * @return <i>true</i> if the objects are equal, <i>false</i> otherwise.
         */
        public boolean equals(Object object) {
        return (compareTo(object) == 0);
        }
        /** Retrieve the description of this list item.
         * @return The description as a <strong>String</strong>.
         */
        public String getDesc() {
        return description;
        }
        /** Retrieve the value of this list item.
         * @return The value as a <strong>String</strong>.
         */
        public String getValue() {
        return value;
        }
            /** Convert this object into a nice readable String.
         * @return A <strong>String</strong> representing this object.
         */
        public String toString() {
        if(text == null) {
            if(description.length() >= MAX_DESC) {
                text = value + StaticStrings.MINUS_CHARACTER + description.substring(0, MAX_DESC) + StaticStrings.TRUNCATED_STRING;
            }
            else {
               text = value + StaticStrings.MINUS_CHARACTER + description;
            }
        }
        return text;
        }
    }
    /** Listener which removes entries from a list from a combobox when fired. */
    private class RemoveListener
        implements ActionListener {
        /** The model behind the target list. */
        private DefaultListModel model = null;
        /** The list to remove data from. */
        private JList target = null;
        /** Constructor.
         * @param target A <strong>JList</strong>.
         */
        public RemoveListener(JList target) {
        this.model = (DefaultListModel) target.getModel();
        this.target = target;
        }
        /** When the remove button is clicked, we attempt to remove the selected metadata from the target.
         * @param event An <strong>ActionEvent</strong> containing information about the event.
         */
        public void actionPerformed(ActionEvent event) {
        if(!target.isSelectionEmpty()) {
            int index = target.getSelectedIndex();
            model.remove(index);
        }
        }
    }
    /** Listener that sets the tooltip associated to a combobox to the tooltip relevant to the selected item. */
    private class ToolTipUpdater
        implements ActionListener {
        /** Any implementation of an ActionListener must include this method so that we can be informed when the selection in a combobox has changed and update the tooltip accordingly.
         * @param event An <strong>ActionEvent</strong> containing information about the action that fired this call.
         */
        public void actionPerformed(ActionEvent event) {
        JComboBox source = (JComboBox)event.getSource();
        ListOption lo = (ListOption)source.getSelectedItem();
        if(lo != null) {
           String description = Utility.formatHTMLWidth(lo.getDesc(), 60);
           source.setToolTipText(description);
        }
        else {
           source.setToolTipText(StaticStrings.EMPTY_STR);
        }
        }
    }
    }
}