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());
}
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);
}
}
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);
}
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()));
}
/** 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()));
}
/**
* 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());
}
private Preferences selectedPreferences() {
PreferencesNode node = this.selectedPreferencesNode();
return (node == null) ? null : node.preferences();
}
