utils/eclipselink.utils.workbench.test/uitools/source/org/eclipse/persistence/tools/workbench/test/uitools/PreferencesPanel.java

/*******************************************************************************
 * Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.tools.workbench.test.uitools;

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.text.Collator;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.prefs.BackingStoreException;
import java.util.prefs.NodeChangeEvent;
import java.util.prefs.NodeChangeListener;
import java.util.prefs.Preferences;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.ListSelectionModel;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.table.TableModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeCellRenderer;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

import org.eclipse.persistence.tools.workbench.uitools.app.CollectionValueModel;
import org.eclipse.persistence.tools.workbench.uitools.app.ListValueModel;
import org.eclipse.persistence.tools.workbench.uitools.app.PropertyValueModel;
import org.eclipse.persistence.tools.workbench.uitools.app.SimplePropertyValueModel;
import org.eclipse.persistence.tools.workbench.uitools.app.SortedListValueModelAdapter;
import org.eclipse.persistence.tools.workbench.uitools.app.adapters.PreferencePropertyValueModel;
import org.eclipse.persistence.tools.workbench.uitools.app.adapters.PreferencesCollectionValueModel;
import org.eclipse.persistence.tools.workbench.uitools.app.swing.ColumnAdapter;
import org.eclipse.persistence.tools.workbench.uitools.app.swing.ListModelAdapter;
import org.eclipse.persistence.tools.workbench.uitools.app.swing.ObjectListSelectionModel;
import org.eclipse.persistence.tools.workbench.uitools.app.swing.TableModelAdapter;
import org.eclipse.persistence.tools.workbench.uitools.cell.SimpleTreeCellRenderer;
import org.eclipse.persistence.tools.workbench.utility.CollectionTools;

/**
 * A panel for displaying a tree of preferences.
 * On the left hand side is a tree of preferences nodes.
 * On the right hand side is a table of the preferences for
 * the currently selected node. The preferences values are
 * displayed and edited as simple strings (as opposed to
 * using the Preferences API that allows you to get and
 * set various other primitive types - e.g. int).
 */
// TODO add popup menu to tree
public class PreferencesPanel extends JPanel {
	/** This is used to sort the nodes and preferences. */
	Collator collator;

	/** This holds the preferences node currently selected in the tree. */
	private PropertyValueModel selectedPreferencesHolder;
	private TreeSelectionModel treeSelectionModel;

	/** This holds the single preference currently selected in the table. */
	private ListValueModel preferencesAdapter;
	private PropertyValueModel selectedPreferenceHolder;
	private TableModel tableModel;
	private ObjectListSelectionModel tableSelectionModel;

	private JPanel controlPanel;

	// ********** constructor/initialization **********

	/**
	 * Construct a panel to display the "system"
	 * and "current user" preferences.
	 */
	public PreferencesPanel() {
		this(null);
	}

	/**
	 * Construct a panel to display the specified preferences.
	 * If the preferences is null, the panel will display the "system"
	 * and "current user" preferences.
	 */
	public PreferencesPanel(Preferences preferences) {
		super(new BorderLayout());
		this.initialize(preferences);
	}

	private void initialize(Preferences preferences) {
		// cache a collator for sorting nodes
		this.collator = Collator.getInstance();
		this.selectedPreferencesHolder = new SimplePropertyValueModel();
		this.selectedPreferenceHolder = new SimplePropertyValueModel();
		this.add(this.buildSplitPane(preferences), BorderLayout.CENTER);
		this.add(this.buildControlPanel(), BorderLayout.SOUTH);
	}

	private JSplitPane buildSplitPane(Preferences preferences) {
		JSplitPane splitPane = new JSplitPane();
		splitPane.setDoubleBuffered(true);
		splitPane.setLeftComponent(new JScrollPane(this.buildTree(preferences)));
		splitPane.setRightComponent(new JScrollPane(this.buildTable()));
		splitPane.setDividerLocation(150);
		return splitPane;
	}

	private JTree buildTree(Preferences preferences) {
		JTree tree = new JTree(this.buildTreeModel(preferences));
		this.treeSelectionModel = tree.getSelectionModel();
		this.treeSelectionModel.setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
		this.treeSelectionModel.addTreeSelectionListener(this.buildTreeSelectionListener());
		tree.setCellRenderer(this.buildTreeCellRenderer());
		tree.setRootVisible(false);
		tree.setShowsRootHandles(true);
		tree.setDoubleBuffered(true);
		return tree;
	}

	private TreeModel buildTreeModel(Preferences preferences) {
		DefaultTreeModel treeModel = new DefaultTreeModel(null, true);	// true = asks allows children
		treeModel.setRoot(this.buildRootNode(preferences, treeModel));
		return treeModel;
	}

	private TreeNode buildRootNode(Preferences preferences, DefaultTreeModel treeModel) {
		try {
			return this.buildRootNode2(preferences, treeModel);
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return null;
		}
	}

	private TreeNode buildRootNode2(Preferences preferences, DefaultTreeModel treeModel) throws BackingStoreException {
		if (preferences == null) {
			return new DefaultRootNode(treeModel);
		}
		return new PreferencesNode(treeModel, preferences);
	}
	private TreeSelectionListener buildTreeSelectionListener() {
		return new TreeSelectionListener() {
			public void valueChanged(TreeSelectionEvent e) {
				PreferencesPanel.this.treeSelectionChanged();
			}
		};
	}

	/**
	 * All the nodes in the tree implement LocalNode.
	 */
	private TreeCellRenderer buildTreeCellRenderer() {
		return new SimpleTreeCellRenderer() {
			protected String buildText(Object value) {
				return ((LocalNode) value).displayString();
			}
		};
	}

	private JTable buildTable() {
		this.preferencesAdapter = this.buildSortedPreferencesAdapter();
		this.tableModel = new TableModelAdapter(this.preferencesAdapter, this.buildColumnAdapter());
		this.tableSelectionModel = this.buildTableSelectionModel(this.preferencesAdapter);

		JTable table = new JTable(this.tableModel);
		table.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);	// see Java bug 5007652
		table.setSelectionModel(this.tableSelectionModel);
		table.setDoubleBuffered(true);
		table.setAutoResizeMode(JTable.AUTO_RESIZE_NEXT_COLUMN);
		return table;
	}

	private ListValueModel buildSortedPreferencesAdapter() {
		return new SortedListValueModelAdapter(this.buildPreferencesAdapter(), this.buildPreferenceComparator());
	}

	/**
	 * Override setting the preference value to truncate the string to the
	 * maximum allowed length.
	 */
	private CollectionValueModel buildPreferencesAdapter() {
		return new PreferencesCollectionValueModel(this.selectedPreferencesHolder) {
			protected PreferencePropertyValueModel buildModel(String key) {
				return new PreferencePropertyValueModel(this.subjectHolder, key) {
					protected String convertToString(Object o) {
						String string = super.convertToString(o);
						if (string == null) {
							return string;
						}
						if (string.length() > Preferences.MAX_VALUE_LENGTH) {
							string = string.substring(0, Preferences.MAX_VALUE_LENGTH);
						}
						return string;
					}

				};
			}

		};
	}

	private Comparator buildPreferenceComparator() {
		return new Comparator() {
			public int compare(Object o1, Object o2) {
				return PreferencesPanel.this.collator.compare(((PreferencePropertyValueModel) o1).getKey(), ((PreferencePropertyValueModel) o2).getKey());
			}
		};
	}

	private ColumnAdapter buildColumnAdapter() {
		return new PreferenceColumnAdapter();
	}

	private ObjectListSelectionModel buildTableSelectionModel(ListValueModel preferencesHolder) {
		ObjectListSelectionModel tsm = new ObjectListSelectionModel(new ListModelAdapter(preferencesHolder));
		tsm.addListSelectionListener(this.buildTableSelectionListener());
		tsm.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
		return tsm;
	}

	private ListSelectionListener buildTableSelectionListener() {
		return new ListSelectionListener() {
			public void valueChanged(ListSelectionEvent e) {
				if (e.getValueIsAdjusting()) {
					return;
				}
				PreferencesPanel.this.tableSelectionChanged(e);
			}
		};
	}

	void tableSelectionChanged(ListSelectionEvent e) {
		this.selectedPreferenceHolder.setValue(this.tableSelectionModel.getSelectedValue());
	}

	private JPanel buildControlPanel() {
		this.controlPanel = new JPanel(new GridLayout(2, 4));
		this.controlPanel.add(this.buildAddNodeButton());
		this.controlPanel.add(this.buildRenameNodeButton());
		this.controlPanel.add(this.buildRemoveNodeButton());
		this.controlPanel.add(this.buildExportButton());
		this.controlPanel.add(this.buildAddPreferenceButton());
		this.controlPanel.add(this.buildRenamePreferenceButton());
		this.controlPanel.add(this.buildRemovePreferenceButton());
		return this.controlPanel;
	}
	private JButton buildAddNodeButton() {
		return new JButton(this.buildAddNodeAction());
	}
	private JButton buildRenameNodeButton() {
		return new JButton(this.buildRenameNodeAction());
	}
	private JButton buildRemoveNodeButton() {
		return new JButton(this.buildRemoveNodeAction());
	}
	private JButton buildExportButton() {
		return new JButton(this.buildExportNodeAction());
	}
	private JButton buildAddPreferenceButton() {
		return new JButton(this.buildAddPreferenceAction());
	}
	private JButton buildRenamePreferenceButton() {
		return new JButton(this.buildRenamePreferenceAction());
	}
	private JButton buildRemovePreferenceButton() {
		return new JButton(this.buildRemovePreferenceAction());
	}


	// ********** public API **********

	public void addAction(Action action) {
		this.controlPanel.add(new JButton(action));
	}


	// ********** accessors **********

	Collator getCollator() {
		return this.collator;
	}


	// ********** behavior **********

	void treeSelectionChanged() {
		this.selectedPreferencesHolder.setValue(this.selectedPreferences());
	}

	private void handleException(Exception ex) {
		ex.printStackTrace();
		JOptionPane.showMessageDialog(this, ex.getMessage(), ex.getClass().getName(), JOptionPane.ERROR_MESSAGE);
	}

	private String promptForNodeName() {
		String name = JOptionPane.showInputDialog("Name");
		if (name == null) {
			return null;
		}
		if (name.length() > Preferences.MAX_NAME_LENGTH) {
			name = name.substring(0, Preferences.MAX_NAME_LENGTH);
		}
		if (name.indexOf('/') != -1) {
			return null;
		}
		return name;
	}

	private String promptForPreferenceName() {
		String name = JOptionPane.showInputDialog("Name");
		if (name == null) {
			return null;
		}
		if (name.length() > Preferences.MAX_KEY_LENGTH) {
			name = name.substring(0, Preferences.MAX_KEY_LENGTH);
		}
		return name;
	}


	// ********** convenience methods **********

	private PreferencesNode selectedPreferencesNode() {
		if (this.treeSelectionModel.getSelectionCount() != 1) {
			return null;
		}
		// the DefaultRootNode should never be visible and selected
		// so we can safely cast to PreferencesNode
		return (PreferencesNode) this.treeSelectionModel.getSelectionPath().getLastPathComponent();
	}

	private Preferences selectedPreferences() {
		PreferencesNode node = this.selectedPreferencesNode();
		return (node == null) ? null : node.preferences();
	}

	private PreferencePropertyValueModel selectedPreference() {
		return (PreferencePropertyValueModel) this.selectedPreferenceHolder.getValue();
	}

	private PreferencePropertyValueModel preference(String key) {
		for (Iterator stream = (Iterator) this.preferencesAdapter.getValue(); stream.hasNext(); ) {
			PreferencePropertyValueModel next = (PreferencePropertyValueModel) stream.next();
			if (next.getKey().equals(key)) {
				return next;
			}
		}
		throw new IllegalArgumentException(key);
	}


	// ********** add child node **********

	private Action buildAddNodeAction() {
		return new AbstractAction("Add Child Node") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.addChildToSelectedNode();
			}
		};
	}

	void addChildToSelectedNode() {
		PreferencesNode selectedNode = this.selectedPreferencesNode();
		if (selectedNode == null) {
			return;
		}
		String name = this.promptForNodeName();
		if (name == null) {
			return;
		}

		Preferences preferences = selectedNode.preferences();
		// this will cause the preferences to be created if it does not already exist
		Preferences newPreferences = preferences.node(name);
		try {
			// flush the change, so an event is fired and the node is
			// created and added to the tree before we try to select it
			preferences.flush();
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of a node that might not be there...
		}
		PreferencesNode newNode = selectedNode.childNodeFor(newPreferences);
		this.treeSelectionModel.setSelectionPath(new TreePath(newNode.getPath()));
	}


	// ********** rename node **********

	private Action buildRenameNodeAction() {
		return new AbstractAction("Rename Node") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.renameSelectedNode();
			}
		};
	}

	/**
	 * we can't simply rename the node - we have to clone
	 * it, then remove it...
	 */
	void renameSelectedNode() {
		PreferencesNode selectedNode = this.selectedPreferencesNode();
		if (selectedNode == null || selectedNode.cannotBeRemoved()) {
			return;
		}

		String name = this.promptForNodeName();
		if (name == null) {
			return;
		}

		Preferences oldPreferences = selectedNode.preferences();
		PreferencesNode parentNode = (PreferencesNode) selectedNode.getParent();
		Preferences parentPreferences = parentNode.preferences();
		try {
			if (parentPreferences.nodeExists(name)) {
				// cannot rename to same name as existing node
				return;
			}
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;
		}

		// clear the selection *before* removing the node, so we are no longer
		// listening to the node when it gets deleted - it will be in an invalid state...
		this.treeSelectionModel.clearSelection();
		Preferences newPreferences = parentPreferences.node(name);
		try {
			this.clone(oldPreferences, newPreferences);
			oldPreferences.removeNode();
			// flush the changes, so events are fired and the tree is updated
			parentPreferences.flush();
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of a node that might not be there...
		}
		PreferencesNode newNode = parentNode.childNodeFor(newPreferences);
		this.treeSelectionModel.setSelectionPath(new TreePath(newNode.getPath()));
	}

	private void clone(Preferences source, Preferences target) throws BackingStoreException {
		String[] names = source.childrenNames();
		int len = names.length;
		for (int i = 0; i < len; i++) {
			String name = names[i];
			this.clone(source.node(name), target.node(name));
		}

		names = source.keys();
		len = names.length;
		for (int i = 0; i < len; i++) {
			String name = names[i];
			target.put(name, source.get(name, ""));
		}
	}


	// ********** remove node **********

	private Action buildRemoveNodeAction() {
		return new AbstractAction("Remove Node") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.removeSelectedNode();
			}
		};
	}

	void removeSelectedNode() {
		PreferencesNode selectedNode = this.selectedPreferencesNode();
		if (selectedNode == null || selectedNode.cannotBeRemoved()) {
			return;
		}

		TreePath postRemoveSelectionPath = this.calculatePostRemoveSelectionPath(selectedNode);
		// clear the selection *before* removing the node, so we are no longer
		// listening to the node when it gets deleted - it will be in an invalid state...
		this.treeSelectionModel.clearSelection();
		Preferences preferences = selectedNode.preferences();
		try {
			preferences.removeNode();
			// flush the change, so an event is fired and the parent node is updated
			preferences.flush();
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of the parent node...
		}
		this.treeSelectionModel.setSelectionPath(postRemoveSelectionPath);
	}

	/**
	 * Calculate what the selection path should be once the
	 * specified node has been removed from the tree.
	 */
	private TreePath calculatePostRemoveSelectionPath(PreferencesNode node) {
		PreferencesNode parentNode = (PreferencesNode) node.getParent();
		int childCount = parentNode.getChildCount();
		if (childCount == 1) {
			// the only child is to be removed - select the parent
			return new TreePath(parentNode.getPath());
		}
		int nodeIndex = parentNode.getIndex(node);
		if (nodeIndex == childCount - 1) {
			// the last child in the list is to be removed - select the previous child
			return new TreePath(((PreferencesNode) parentNode.getChildAt(nodeIndex - 1)).getPath());
		}
		// by default, select the next child
		return new TreePath(((PreferencesNode) parentNode.getChildAt(nodeIndex + 1)).getPath());
	}


	// ********** export **********

	private Action buildExportNodeAction() {
		return new AbstractAction("Export Node") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.exportSelectedNode();
			}
		};
	}

	void exportSelectedNode() {
		PreferencesNode selectedNode = this.selectedPreferencesNode();
		if (selectedNode == null) {
			return;
		}
		JFileChooser fc = new JFileChooser();
		int rc = fc.showSaveDialog(this);
		if (rc != JFileChooser.APPROVE_OPTION) {
			return;
		}
		try {
			OutputStream stream = new BufferedOutputStream(new FileOutputStream(fc.getSelectedFile()), 2048);
			selectedNode.preferences().exportSubtree(stream);
			stream.close();
		} catch (IOException ex) {
			this.handleException(ex);
		} catch (BackingStoreException ex) {
			this.handleException(ex);
		}
	}


	// ********** add preference **********

	private Action buildAddPreferenceAction() {
		return new AbstractAction("Add Preference") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.addPreferenceToSelectedNode();
			}
		};
	}

	void addPreferenceToSelectedNode() {
		Preferences preferences = this.selectedPreferences();
		if (preferences == null) {
			return;
		}
		String name = this.promptForPreferenceName();
		if (name == null) {
			return;
		}

		try {
			if (CollectionTools.contains(preferences.keys(), name)) {
				return;
			}
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of a row that might not be there...
		}
		preferences.put(name, "");
		try {
			// flush the change, so an event is fired and the preference is
			// created and added to the table before we try to select it
			preferences.flush();
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of a row that might not be there...
		}
		this.tableSelectionModel.setSelectedValue(this.preference(name));
	}


	// ********** rename preference **********

	private Action buildRenamePreferenceAction() {
		return new AbstractAction("Rename Preference") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.renameSelectedPreference();
			}
		};
	}

	void renameSelectedPreference() {
		PreferencePropertyValueModel preference = this.selectedPreference();
		if (preference == null) {
			return;
		}

		String name = this.promptForPreferenceName();
		if (name == null) {
			return;
		}

		Preferences preferences = this.selectedPreferences();
		try {
			if (CollectionTools.contains(preferences.keys(), name)) {
				return;
			}
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;
		}

		String value = (String) preference.getValue();
		preferences.put(name, value);
		preferences.remove(preference.getKey());
		try {
			// flush the changes, so events are fired and the table is updated
			preferences.flush();
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of a node that might not be there...
		}
		this.tableSelectionModel.setSelectedValue(this.preference(name));
	}


	// ********** remove preference **********

	private Action buildRemovePreferenceAction() {
		return new AbstractAction("Remove Preference") {
			public void actionPerformed(ActionEvent event) {
				PreferencesPanel.this.removeSelectedPreference();
			}
		};
	}

	void removeSelectedPreference() {
		PreferencePropertyValueModel preference = this.selectedPreference();
		if (preference == null) {
			return;
		}

		Preferences preferences = this.selectedPreferences();
		preferences.remove(preference.getKey());
		try {
			// flush the change, so an event is fired and the table is updated
			preferences.flush();
		} catch (BackingStoreException ex) {
			this.handleException(ex);
			return;	// skip the selection of the parent node...
		}
	}


// ********** inner classes **********

/**
 * Define interface used by the tree cell renderer.
 */
private interface LocalNode {
	String displayString();
}


/**
 * The implied root node that holds both the system
 * and current user root nodes.
 */
private class DefaultRootNode
	extends DefaultMutableTreeNode
	implements LocalNode
{
	private static final String NAME = "Root";

	DefaultRootNode(DefaultTreeModel treeModel) throws BackingStoreException {
		super(NAME, true);	// true = allows children
		this.initialize(treeModel);
	}

	private void initialize(DefaultTreeModel treeModel) throws BackingStoreException {
		// the "default root" node has two, hard-coded children
		this.add(this.buildNode(treeModel, Preferences.systemRoot(), "System"));
		this.add(this.buildNode(treeModel, Preferences.userRoot(), "User"));
	}

	private MutableTreeNode buildNode(DefaultTreeModel treeModel, Preferences preferences, String rootName) throws BackingStoreException {
		return new RootPreferencesNode(treeModel, preferences, rootName);
	}

	/**
	 * Simply display the string "root".
	 * @see org.eclipse.persistence.tools.workbench.test.uitools.PreferencesPanel.LocalNode#displayString()
	 */
	public String displayString() {
		return NAME;
	}

}


/**
 * A node for a Preferences. It will automatically populate itself
 * with the appropriate child nodes upon construction. Then it
 * will listen for any child nodes being added or removed and update
 * itself accordingly.
 */
private class PreferencesNode
	extends DefaultMutableTreeNode
	implements LocalNode, NodeChangeListener, Comparable
{
	private DefaultTreeModel treeModel;


	// ********** constructor/initialization **********

	PreferencesNode(DefaultTreeModel treeModel, Preferences preferences) throws BackingStoreException {
		super(preferences, true);	// true = allows children
		this.treeModel = treeModel;
		this.preferences().addNodeChangeListener(this);
		this.initializeChildNodes();
	}

	/**
	 * Add nodes for the preferences's "children" (which are other preferenceses).
	 */
	private void initializeChildNodes() throws BackingStoreException {
		Preferences preferences = this.preferences();
		String[] childrenNames = (String[]) CollectionTools.sort(preferences.childrenNames(), this.collator());
		int len = childrenNames.length;
		for (int i = 0; i < len; i++) {
			this.add(this.buildNode(preferences.node(childrenNames[i])));
		}
	}

	private PreferencesNode buildNode(Preferences preferences) throws BackingStoreException {
		return new PreferencesNode(this.treeModel, preferences);
	}


	// ********** LocalNode implementation **********

	/**
	 * Display the preferences's name.
	 * @see org.eclipse.persistence.tools.workbench.test.uitools.PreferencesPanel.LocalNode#displayString()
	 */
	public String displayString() {
		return this.name();
	}


	// ********** NodeChangeListener implementation **********

	/**
	 * @see java.util.prefs.NodeChangeListener#childAdded(java.util.prefs.NodeChangeEvent)
	 */
	public void childAdded(NodeChangeEvent evt) {
		try {
			this.addNodeFor(evt.getChild());
		} catch (BackingStoreException ex) {
			throw new RuntimeException(ex);
		}
	}

	private void addNodeFor(Preferences preferences) throws BackingStoreException {
		PreferencesNode childNode = this.buildNode(preferences);
		this.treeModel.insertNodeInto(childNode, this, this.insertionIndexOf(childNode));
	}

	private int insertionIndexOf(PreferencesNode childNode) {
		return (this.children == null) ? 0 : CollectionTools.insertionIndexOf(this.children, childNode);
	}

	/**
	 * @see java.util.prefs.NodeChangeListener#childRemoved(java.util.prefs.NodeChangeEvent)
	 */
	public void childRemoved(NodeChangeEvent evt) {
		this.removeChildNodeFor(evt.getChild());
	}

	private void removeChildNodeFor(Preferences preferences) {
		this.treeModel.removeNodeFromParent(this.childNodeFor(preferences));
	}

	PreferencesNode childNodeFor(Preferences child) {
		for (Enumeration stream = this.children(); stream.hasMoreElements(); ) {
			PreferencesNode childNode = (PreferencesNode) stream.nextElement();
			if (childNode.preferences() == child) {
				return childNode;
			}
		}
		throw new IllegalArgumentException(child.toString());
	}

											
	// ********** Comparable implementation **********

	/**
	 * @see java.lang.Comparable#compareTo(java.lang.Object)
	 */
	public int compareTo(Object o) {
		return this.collator().compare(this.name(), ((PreferencesNode) o).name());
	}


	// ********** other methods **********

	Preferences preferences() {
		return (Preferences) this.getUserObject();
	}

	private Collator collator() {
		return PreferencesPanel.this.getCollator();
	}

	/**
	 * Return whether the node can be removed.
	 * Most nodes can be removed.
	 */
	boolean canBeRemoved() {
		return true;
	}

	/**
	 * Return whether the node cannot be removed.
	 */
	boolean cannotBeRemoved() {
		return ! this.canBeRemoved();
	}

	String name() {
		return this.preferences().name();
	}

}


/**
 * A node for a "root" Preferences (system or user). The "root" Preferences
 * do not have names, so require one to be supplied upon construction.
 */
private class RootPreferencesNode extends PreferencesNode {
	private String rootName;

	RootPreferencesNode(DefaultTreeModel treeModel, Preferences rootPreferences, String rootName) throws BackingStoreException {
		super(treeModel, rootPreferences);
		this.rootName = rootName;
	}

	public String displayString() {
		return this.rootName;
	}

	/**
	 * Return whether the node can be removed.
	 * Root nodes canNOT be removed.
	 */
	boolean canBeRemoved() {
		return false;
	}

}


/**
 * There are 2 columns: one for the preference key and one for the preference
 * value. Everything is displayed and edited as strings.
 */
private static class PreferenceColumnAdapter implements ColumnAdapter {
	public static final int COLUMN_COUNT = 2;

	public static final int KEY_COLUMN = 0;
	public static final int VALUE_COLUMN = 1;

	private static final String[] COLUMN_NAMES = new String[] {"Key", "Value"};


	public int getColumnCount() {
		return COLUMN_COUNT;
	}

	public String getColumnName(int index) {
		return COLUMN_NAMES[index];
	}

	public Class getColumnClass(int index) {
		switch (index) {
			case KEY_COLUMN:			return Object.class;
			case VALUE_COLUMN:		return Object.class;
			default: 						return Object.class;
		}
	}

	public boolean isColumnEditable(int index) {
		return index != KEY_COLUMN;
	}

	public PropertyValueModel[] cellModels(Object subject) {
		PreferencePropertyValueModel preference = (PreferencePropertyValueModel) subject;
		PropertyValueModel[] result = new PropertyValueModel[COLUMN_COUNT];

		result[KEY_COLUMN]		= new SimplePropertyValueModel(preference.getKey());
		result[VALUE_COLUMN]		= preference;

		return result;
	}

}


}