source: trunk/gli/src/org/greenstone/gatherer/cdm/FormatManager.java@ 4932

/**
 *#########################################################################
 *
 * 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;
/**************************************************************************************
 * Written:     06/05/02
 * Revised:     04/10/02 - Commented
 *              14/07/03 - DOM support
 **************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.event.*;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.cdm.Classifier;
import org.greenstone.gatherer.cdm.ClassifierManager;
import org.greenstone.gatherer.cdm.CollectionConfiguration;
import org.greenstone.gatherer.cdm.CollectionDesignManager;
import org.greenstone.gatherer.cdm.CommandTokenizer;
import org.greenstone.gatherer.cdm.Control;
import org.greenstone.gatherer.cdm.DOMProxyListModel;
import org.greenstone.gatherer.cdm.Format;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.util.Utility;
import org.w3c.dom.*;
/** This class maintains a list of format statements, and allows the addition and removal of these statements.
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 */
public class FormatManager
    extends DOMProxyListModel {

    /** The controls used to edit the format commands. */
    private Control controls = null;
    /** A reference to ourselves so inner classes can get at the model. */
    private DOMProxyListModel model = null;

    /** Constructor. */
    public FormatManager() {
    super(CollectionDesignManager.collect_config.getDocumentElement(), CollectionConfiguration.FORMAT_ELEMENT, new Format());
    this.model = this;
    Gatherer.println("FormatManager: parsed " + getSize() + " format statements.");
    // Establish all of the format objects, so that classifier indexes are initially correct (subsequent refreshes of the model will be sufficient to keep these up to date, as long as we start with a live reference to a classifier.
    int size = getSize();
    for(int i = 0; i < size; i++) {
        getElementAt(i);
    }
    }
    /** Method to add a new format to this manager.
      * @param format The <strong>Format</strong> to add.
      */
    public void addFormat(Format format) {
    if(!contains(format)) {
        Element element = format.getElement();
        // Locate where we should insert this new classifier. 
        Node target_node = CollectionConfiguration.findInsertionPoint(element);
        add(root, format, target_node);
        Gatherer.c_man.configurationChanged();
    }
    }

    public void destroy() {
    if(controls != null) {
        controls.destroy();
        controls = null;
    }
    }

    /** Gets the format indicated by the index.
     * @param index The location of the desired format, as an <i>int</i>.
     */
    public Format getFormat(int index) {
    Format result = null;
    if(0 < index && index < getSize()) {
        result = (Format) getElementAt(index);
    }
    return result;
    }
    
    /** Method to retrieve this managers controls.
     * @return the Control for this collection.
     */
    public Control getControls() {
    if(controls == null) {
        controls = new FormatControl();
    }
    return controls;
    }

    /** Method to remove a format.
     * @param format The <strong>Format</strong> to remove.
     */
    public void removeFormat(Format format) {
    remove(format);
    Gatherer.c_man.configurationChanged();
    }

    /** Overloaded to call get with both a key and an empty argument array.
     * @param key A <strong>String</strong> which is mapped to a initial String within the ResourceBundle.
     * @return A <strong>String</strong> which has been referenced by the key String and that either contains no argument fields, or has had the argument fields automatiically populated with formatting Strings of with argument String provided in the get call.
     */
    private String get(String key) {
    return get(key, null);
    }

    /** Used to retrieve a property value from the Locale specific ResourceBundle, based upon the key and arguments supplied. If the key cannot be found or if some other part of the call fails a default (English) error message is returned. <BR>
     * Here the get recieves a second argument which is an array of Strings used to populate argument fields, denoted {<I>n</I>}, within the value String returned. Note that argument numbers greater than or equal to 32 are automatically mapped to the formatting String named Farg<I>n</I>.
     * @param key A <strong>String</strong> which is mapped to a initial String within the ResourceBundle.
     * @param args A <strong>String[]</strong> used to populate argument fields within the complete String.
     * @return A <strong>String</strong> which has been referenced by the key String and that either contains no argument fields, or has had the argument fields automatiically populated with formatting Strings of with argument String provided in the get call.
     * @see org.greenstone.gatherer.Gatherer
     * @see org.greenstone.gatherer.Dictionary
     */
    private String get(String key, String args[]) {
    if(key.indexOf('.') == -1) {
        key = "CDM.FormatManager." + key;
    }
    return Gatherer.dictionary.get(key, args);
    }

    private class FormatControl
    extends JPanel 
    implements Control {
    /** Do we ignore selection changing events (mainly because we're generating them!) */
    private boolean ignore = false;
    private boolean new_entry = true;
    private boolean ready = false;
    private ButtonGroup button_group = null;
    private CardLayout card_layout = null;
    private Dimension LABEL_SIZE = new Dimension(175,25);
    private Format current_format = null;
    private String view_type = "custom";
    private JButton add = null;
    private JButton insert = null;
    private JButton preview = null;
    private JButton remove = null;
    private JComboBox feature = null;
    private JComboBox part = null;
    private JComboBox special = null;
    private JLabel editor_label = null;
    private JLabel feature_label = null;
    private JLabel format_list_label = null;
    private JLabel part_label = null;
    private JLabel special_label = null;
    private JLabel title = null;
    private JLabel value_label = null;
    private JList format_list = null;
    private JPanel blank_pane = null;
    private JPanel control_pane = null;
    private JPanel editor_pane = null;
    private JPanel feature_pane = null;
    private JPanel format_list_pane = null;
    private JPanel header_pane = null;
    private JPanel inner_button_pane = null;
    private JPanel inner_state_pane = null;
    private JPanel inner_value_pane = null;
    private JPanel options_pane = null;
    private JPanel outer_button_pane = null;
    private JPanel part_pane = null;
    private JPanel special_pane = null;
    private JPanel state_pane = null;
    private JPanel value_pane = null;
    private JPanel view_pane = null;
    private JTextArea editor = null;
    private JTextArea instructions = null;
    private JTextField value = null;
    private JToggleButton off = null;
    private JToggleButton on = null;
    private String BLANK = "blank";
    private String CUSTOM = "custom";
    private String FLAG = "flag";
    private String PARAM = "param";
    private Vector part_model = null;
    private Vector special_model = null;
    public FormatControl() {
        ArrayList feature_model = buildFeatureModel();
        part_model = new Vector();
        part_model.add("");//get("Custom"));
        part_model.add("DateList");
        part_model.add("HList");
        part_model.add("Invisible");
        part_model.add("VList");
        special_model = new Vector();
        special_model.add("[Text]");
        special_model.add("[link]");
        special_model.add("[/link]");
        special_model.add("[icon]");
        special_model.add("[num]");
        special_model.add("[parent():_]");
        special_model.add("[parent(Top):_]");
        special_model.add("[parent(All'_'):_]");
        Vector elements = Gatherer.c_man.getCollection().msm.getAssignedElements();
        for(int i = 0; i < elements.size(); i++) {
        special_model.add("[" + ((ElementWrapper)elements.get(i)).toString() + "]");
        }
        Collections.sort(special_model);
        // Create
        add = new JButton(get("Add"));
        add.setEnabled(false);
        blank_pane = new JPanel();
        button_group = new ButtonGroup();
        card_layout = new CardLayout();
        control_pane = new JPanel();
        editor = new JTextArea();
        editor.setBackground(Gatherer.config.getColor("coloring.editable", false));
        editor.setCaretPosition(0);
        editor.setLineWrap(true);
        editor.setWrapStyleWord(false);
        editor_label = new JLabel(get("Editor"));
        editor_label.setHorizontalAlignment(JLabel.CENTER);
        editor_pane = new JPanel();
        feature = new JComboBox(feature_model.toArray());
        feature.setEditable(false);
        feature_label = new JLabel(get("Feature"));
        feature_label.setPreferredSize(LABEL_SIZE);
        format_list = new JList(model);
        format_list_label = new JLabel(get("Assigned_Formats"));
        format_list_pane = new JPanel();
        feature_pane = new JPanel();
        header_pane = new JPanel();
        inner_button_pane = new JPanel();
        inner_state_pane = new JPanel();
        inner_value_pane = new JPanel();
        insert = new JButton(get("Insert"));
        instructions = new JTextArea(get("Instructions"));
        instructions.setBackground(Gatherer.config.getColor("coloring.collection_tree_background", false));
        instructions.setEditable(false);
        instructions.setLineWrap(true);
        instructions.setRows(4);
        instructions.setWrapStyleWord(true);
        off = new JToggleButton(get("Off"));
        off.setSelected(false);
        on = new JToggleButton(get("On"));
        on.setSelected(true);
        options_pane = new JPanel();
        outer_button_pane = new JPanel();
        part = new JComboBox(part_model);
        part.setEditable(false);
        part_label = new JLabel(get("Part"));
        part_label.setPreferredSize(LABEL_SIZE);
        part_pane = new JPanel();
        preview = new JButton(get("Preview"));
        preview.setEnabled(false);
        remove = new JButton(get("Remove"));
        remove.setEnabled(false);
        special = new JComboBox(special_model);
        special_label = new JLabel(get("Special"));
        special_label.setHorizontalAlignment(JLabel.CENTER);
        special_pane = new JPanel();
        state_pane = new JPanel();
        title = new JLabel(get("Title"));
        title.setHorizontalAlignment(JLabel.CENTER);
        title.setOpaque(true);
        value = new JTextField();
        value_label = new JLabel(get("Value"));
        value_pane = new JPanel();
        view_pane = new JPanel();
        // Connect
        add.addActionListener(new AddListener());
        button_group.add(on);
        button_group.add(off);
        editor.getDocument().addDocumentListener(new EditorListener());
        feature.addActionListener(new FeatureListener());
        format_list.addListSelectionListener(new FormatListListener());
        insert.addActionListener(new InsertListener());
        off.addActionListener(new StateListener());
        on.addActionListener(new StateListener());
        part.addActionListener(new PartListener());
        preview.addActionListener(new PreviewListener());
        remove.addActionListener(new RemoveListener());
        value.addKeyListener(new ValueListener());
                // Layout
        instructions.setBorder(BorderFactory.createEmptyBorder(2,5,2,5));

        header_pane.setLayout(new BorderLayout());
        header_pane.add(title, BorderLayout.NORTH);
        header_pane.add(new JScrollPane(instructions), BorderLayout.CENTER);

        format_list_label.setBorder(BorderFactory.createEmptyBorder(5,0,5,0));

        format_list_pane.setLayout(new BorderLayout());
        format_list_pane.add(format_list_label, BorderLayout.NORTH);
        format_list_pane.add(new JScrollPane(format_list), BorderLayout.CENTER);

        feature_label.setBorder(BorderFactory.createEmptyBorder(0,0,0,5));

        feature_pane.setBorder(BorderFactory.createEmptyBorder(5,0,5,0));
        feature_pane.setLayout(new BorderLayout());
        feature_pane.add(feature_label, BorderLayout.WEST);
        feature_pane.add(feature, BorderLayout.CENTER);

        part_label.setBorder(BorderFactory.createEmptyBorder(0,0,0,5));

        part_pane.setBorder(BorderFactory.createEmptyBorder(5,0,5,0));
        part_pane.setLayout(new BorderLayout());
        part_pane.add(part_label, BorderLayout.WEST);
        part_pane.add(part, BorderLayout.CENTER);

        options_pane.setLayout(new GridLayout(2,1));
        options_pane.add(feature_pane);
        options_pane.add(part_pane);

        inner_state_pane = new JPanel(new GridLayout(1,2));
        inner_state_pane.add(on);
        inner_state_pane.add(off);

        state_pane.setLayout(new BorderLayout());
        state_pane.add(inner_state_pane, BorderLayout.NORTH);
        state_pane.add(new JPanel(), BorderLayout.CENTER);

        value_label.setBorder(BorderFactory.createEmptyBorder(0,0,0,5));

        inner_value_pane.setLayout(new BorderLayout());
        inner_value_pane.add(value_label, BorderLayout.WEST);
        inner_value_pane.add(value, BorderLayout.CENTER);

        value_pane.setLayout(new BorderLayout());
        value_pane.add(inner_value_pane, BorderLayout.NORTH);
        value_pane.add(new JPanel(), BorderLayout.CENTER);

        special_pane.setLayout(new GridLayout(3,1));
        special_pane.add(special_label);
        special_pane.add(special);
        special_pane.add(insert);

        editor_pane.setLayout(new BorderLayout());
        editor_pane.add(editor_label, BorderLayout.NORTH);
        editor_pane.add(new JScrollPane(editor), BorderLayout.CENTER);
        editor_pane.add(special_pane, BorderLayout.EAST);

                // Magic for view_pane card layout.
        view_pane.setLayout(card_layout);
        view_pane.add(editor_pane, CUSTOM);
        view_pane.add(state_pane, FLAG);
                //view_pane.add(value_pane, PARAM);

        inner_button_pane.setLayout(new GridLayout(1,2));
        inner_button_pane.add(add);
        inner_button_pane.add(remove);

        outer_button_pane.setBorder(BorderFactory.createEmptyBorder(5,0,0,0));
        outer_button_pane.setLayout(new GridLayout(1,1));
        outer_button_pane.add(inner_button_pane);
                //outer_button_pane.add(preview);

        control_pane.setLayout(new BorderLayout());
        control_pane.add(options_pane, BorderLayout.NORTH);
        control_pane.add(view_pane, BorderLayout.CENTER);
        control_pane.add(outer_button_pane, BorderLayout.SOUTH);

        setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
        setLayout(new BorderLayout());
        add(header_pane, BorderLayout.NORTH);
        add(format_list_pane, BorderLayout.CENTER);
        add(control_pane, BorderLayout.SOUTH);
        ready = true;
    }

    public void destroy() {
    }

    /** Overriden to ensure that the instructions pane is scrolled to the top.
     */
    public void gainFocus() {
        // This is only necessary if the components have been realized
        if(ready) {
        model.refresh();
        ArrayList feature_model = buildFeatureModel();
        // Remember the current selection
        Object selected_object = feature.getSelectedItem();
        feature.setModel(new DefaultComboBoxModel(feature_model.toArray()));
        // Now resotre the selected object as best as possible
        feature.setSelectedItem(selected_object);
        if(instructions != null) {
            instructions.setCaretPosition(0);
        }
        }   
    }

    public void loseFocus() {
        // Force all of the Formats to update their names with the correct values.
        int size = model.getSize();
        for(int i = 0; i < size; i++) {
        Format format = (Format) model.getElementAt(i);
        format.update();
        }
    }

    private ArrayList buildFeatureModel() {
        // Rebuild feature model.
        ArrayList feature_model = new ArrayList();
        // Add the set options
        for(int i = 0; i < Format.DEFAULT_FEATURES.length; i++) {
        feature_model.add(new Entry(Format.DEFAULT_FEATURES[i]));
        }
        // Now the classifiers.
        for(int j = 0; j < CollectionDesignManager.classifier_manager.getSize(); j++) {
        feature_model.add(new Entry(CollectionDesignManager.classifier_manager.getClassifier(j)));
        }
        Collections.sort(feature_model);
        return feature_model;
    }

    /** Formats the formatting string so that it contains safe characters and isn't enclosed in speech marks etc. (Ironic eh?)
     * @see java.lang.StringBuffer
     */
    private String format(String raw) {
        String safe = null;
        if(raw != null && raw.length() > 0) {
        StringBuffer temp = new StringBuffer(raw);
        // Remove quotes at start and end. Look at my wiggly save three lines of code skills.
        char start = ' ';
        while(temp.length() > 0 && (start = temp.charAt(0)) == '\"' || start == '\'') {
            temp.delete(0, 1);
        }
        int length = 0;
        char end = ' ';
        while((length = temp.length()) > 0 && (end = temp.charAt(length - 1)) == '\"' || end == '\'') {
            temp.delete(length - 1, length);
        }
        // Now escape quotes within the format string
        int quote_index = -1;
        while((quote_index = temp.indexOf("\"", quote_index + 1)) != -1) {
            temp.replace(quote_index, quote_index + 1, "\\\"");
            quote_index = quote_index + 1;
        }
        // Done.
        safe = temp.toString();
        }
        return safe;
    }
    /** Remove safe characters from string replacing them with unsafe ones.
            * @see java.lang.StringBuffer
            */
    private String unformat(String safe) {
        String raw = null;
        if(safe != null && safe.length() > 0) {
        StringBuffer temp = new StringBuffer(safe);
        int quote_index = -1;
        while((quote_index = temp.indexOf("\\\"")) != -1) {
            temp.replace(quote_index, quote_index + 2, "\"");
        }
        raw = temp.toString();
        }
        return raw;
    }

    /** Listens for clicks on the add button, and if the relevant details are provided adds a new format. */
    private class AddListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        //ignore = true;
        Entry entry = (Entry)feature.getSelectedItem();
        Object f = entry.getFeature();
        String p = (String)part.getSelectedItem();
        if(view_type.equals(FLAG)) {
            current_format = new Format(f, p, on.isSelected());
        }
        else {
            current_format = new Format(f, p, format(Utility.stripNL(editor.getText())));
        }
        addFormat(current_format);
        add.setEnabled(false);
        remove.setEnabled(true);
        // Update list selection
        format_list.setSelectedValue(current_format, true);
        new_entry = false;
        //ignore = false;
        }
    }

    private class EditorListener
        implements DocumentListener {
 
        public void changedUpdate(DocumentEvent e) {
        update();
        }
          
        public void insertUpdate(DocumentEvent e) {
        update();
        }
          
        public void removeUpdate(DocumentEvent e) {
        update();
        }

        public void update() {
        String safe = format(editor.getText());
        if(!ignore && current_format != null) {
            // We have just performed an edit. Immediately update the format and model.
            if(safe != null) {
            current_format.setValue(safe);
            }
            else {
            current_format.setValue("");
            }
            Gatherer.c_man.configurationChanged();
            model.refresh(current_format);
        }
        Entry entry = (Entry) feature.getSelectedItem();
        String name = entry.toString();
        if(!(name.length() == 0 && ((String)part.getSelectedItem()).length() == 0) && safe != null && safe.length() != 0 && new_entry) {
            add.setEnabled(true);
        }
        else {
            add.setEnabled(false);
        }
        }
    }

    /** This object provides a wrapping around an entry in the format target control, which is tranparent as to whether it is backed by a String or a Classifier. */
    private class Entry
        implements Comparable {
        private Classifier classifier = null;
        private CustomClassifier custom_classifier = null;
        private String text = null;
        public Entry(Object object) {
        if(object instanceof Classifier) {
            classifier = (Classifier)object;
        }
        if(object instanceof CustomClassifier) {
            custom_classifier = (CustomClassifier)object;
        }
        else if(object instanceof String) {
            text = (String)object;
        }
        else {
            text = "";
        }
        }
        public Entry(String text) {
        this.text = text;
        }
        public int compareTo(Object object) {
        if(object == null) {
            return 1;
        }
        if(toString() == null) {
            return -1;
        }
        else {
            String object_str = object.toString();
            if(object_str == null) {
            return 1;
            }
            return toString().compareTo(object_str);
        }
        }
        public boolean equals(Object object) {
        if(compareTo(object) == 0) {
            return true;
        }
        return false;
        }
        public Classifier getClassifier() {
        return classifier;
        }
        public CustomClassifier getCustomClassifier() {
        return custom_classifier;
        }
        public Object getFeature() {
        if(classifier != null) {
            return classifier;
        }
        return text;
        }
        public String toString() {
        if(classifier != null) {
            String name = classifier.toString();
            return name.substring(9);
        }
        if(custom_classifier != null) {
            String name = custom_classifier.toString();
            return name;//.substring(17);
        }
        return text;
        }
    }

    private class FeatureListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        if(!ignore) {
            current_format = null;
            Entry entry = (Entry) feature.getSelectedItem();
            String name = entry.toString();
            if(Format.isParamType(name)) {
            // Flags first.
            part.setEnabled(false);
            part_pane.remove(part);
            card_layout.show(view_pane, FLAG);
            view_type = FLAG;
            add.setEnabled(true); // One of the options must be selected.
            }
            else {
            part.setEnabled(true);
            part_pane.add(part, BorderLayout.CENTER);
            card_layout.show(view_pane, CUSTOM);
            view_type = CUSTOM;
            if(!(name.length() == 0 && ((String)part.getSelectedItem()).length() == 0) && editor.getText().length() != 0) {
                add.setEnabled(true);
            }
            else {
                add.setEnabled(false);
            }
            }
            control_pane.updateUI();
            new_entry = true;
        }
        }
    }

    private class FormatListListener
        implements ListSelectionListener {
        public void valueChanged(ListSelectionEvent event) {
        if(!ignore) {
            if(!format_list.isSelectionEmpty()) {
            ignore = true;
            current_format = (Format)format_list.getSelectedValue();
            // Try to match the target, remembering the entries within are Entry's
            Entry an_entry = new Entry(current_format.getFeature());
            feature.setSelectedItem(an_entry);
            // If we didn't match anything, add it and select it again
            Entry result_entry = (Entry) feature.getSelectedItem();
            if(!an_entry.equals(result_entry)) {
                feature.insertItemAt(an_entry, feature.getItemCount());
                feature.setSelectedItem(an_entry);
            }
            
            if(current_format.canHavePart()) {
                part.setEnabled(true);
                // Try to match the part.
                String part_entry = current_format.getPart();
                part.setSelectedItem(part_entry);
                // If we didn't match anything, add it and select it again
                String selected_part = (String)part.getSelectedItem();
                if(!part_entry.equals(selected_part)) {
                part.insertItemAt(part_entry, part.getItemCount());
                feature.setSelectedItem(part_entry);
                }
            }
            else {
                part.setEnabled(false);
            }
            // Now use type to determine what controls are visible, and what have initial values.
            if(current_format.isParamType()) {
                // Flags first.
                part.setEnabled(false);
                part_pane.remove(part);
                card_layout.show(view_pane, FLAG);
                view_type = FLAG;
                // Initial value
                on.setSelected(current_format.getState());
                off.setSelected(!current_format.getState());
                add.setEnabled(false); // Can only update
            }
            else {
                part.setEnabled(true);
                part_pane.add(part, BorderLayout.CENTER);
                card_layout.show(view_pane, CUSTOM);
                view_type = CUSTOM;
                // Initial value
                editor.setText(unformat(current_format.getValue()));
                add.setEnabled(false);
            }
            control_pane.updateUI();
            ignore = false;
            preview.setEnabled(true);
            remove.setEnabled(true);
            new_entry = false;
            }
            else {
            preview.setEnabled(false);
            remove.setEnabled(false);
            }
        }
        }
    }
    private class InsertListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        editor.insert((String)special.getSelectedItem(), editor.getCaretPosition());
        }
    }
    private class PartListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        if(!ignore) {
            current_format = null;
            Entry entry = (Entry) feature.getSelectedItem();
            String name = entry.toString();
            if(!(name.length() == 0 && ((String)part.getSelectedItem()).length() == 0) && editor.getText().length() != 0) {
            add.setEnabled(true);
            }
            else {
            add.setEnabled(false);
            }
            new_entry = true;
        }
        }
    }
    private class PreviewListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        }
    }
    private class RemoveListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        if(!format_list.isSelectionEmpty()) {
            removeFormat((Format)format_list.getSelectedValue());
            // Change buttons
            add.setEnabled(true);
            remove.setEnabled(false);
        }
        }
    }
    private class StateListener
        implements ActionListener {
        public void actionPerformed(ActionEvent event) {
        if(!ignore && current_format != null) {
            // We have just performed an edit. Immediately update the format and model.
            current_format.setState(on.isSelected());
            model.refresh(current_format);
        }
        }
    }
    private class ValueListener
        extends KeyAdapter {
        public void keyReleased(KeyEvent event) {
        if(!ignore && current_format != null) {
            // We have just performed an edit. Immediately update the format and model.
            current_format.setValue(value.getText());
            model.refresh(current_format);
        }
        }
    }
    }
}