Bug na API java.util.prefs

/*
   XMLPreferences.java
 */

import java.util.Vector;
import java.util.prefs.AbstractPreferences;
import java.util.prefs.BackingStoreException;

import org.w3c.dom.*;

/**
 * This implementation of AbstractPreferences contains the SPI methods
 * as defined in java.util.prefs.AbstractPreferences. These SPI iplementations
 * make the preferences backing store an XML file. To avoid disk read-write
 * issues, the Document tree is only saved to a file when the 'flush' method
 * is called.
 * 
 * This class assumes that there is a PreferencesController singleton object, 
 * which will take care of creating or loading an XML file to a DOM Document.
 * 
 * Though the DTD provided for the preferences API has been followed in this
 * implementation, the current DOM API doesn't provide a method to set a 
 * Document's DOCTYPE, so no DOCTYPE will be seen on XML files generated
 * by this implementation.
 * 
 * @author Eduardo S. Cordeiro and Tays C. A. P. Soares
 */
public class XMLPreferences extends AbstractPreferences {

	/**
	 * Creates an instance of a preferences node, and sets the 'newNode'
	 * flag to null.
	 * @param parent the parent of this node
	 * @param name the name of this node
	 */
	public XMLPreferences(AbstractPreferences parent, String name) {
		super(parent, name);
		newNode = true;
	}

	/**
	 * Requests the PreferencesController to save the preferences tree
	 * to the backing store. Please note that, though the AbstractPreferences
	 * method signature defines that this method should throw a BackingStoreException,
	 * this implementation doesn't.
	 */
	protected void flushSpi() throws BackingStoreException {
		PreferencesController.getInstance().savePreferences();
	}

	/**
	 * Removes this node from the backing store. Please note that, though the 
	 * AbstractPreferences method signature defines that this method should 
	 * throw a BackingStoreException, this implementation doesn't.
	 */
	protected void removeNodeSpi() throws BackingStoreException {
		org.w3c.dom.Node root = PreferencesController.getInstance().getXMLDocument().getDocumentElement();
		Element my_node = myXMLNode();
		Element parent_node = (Element)my_node.getParentNode();
		
		if(root.getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) {
			Element doc_root = (Element) root;
			
			parent_node.removeChild(my_node);
		}	
	}

	/**
	 * Not implemented, but a future TO-DO.
	 */
	protected void syncSpi() throws BackingStoreException {}

	/**
	 * Retrieves a String array with the names of this node's children from
	 * the backing store. Please note that, though the AbstractPreferences
	 * method signature defines that this method should throw a BackingStoreException,
	 * this implementation doesn't.
	 * @return a String array with the names of this node's children
	 */
	protected String[] childrenNamesSpi() throws BackingStoreException {
		Element node = myXMLNode();
		Vector node_names = null;
		
		if (node != null) {
			NodeList children = node.getChildNodes();
			node_names = new Vector();
			for (int i=0 ; i<children.getLength() ; i++) {
				Element child = (Element)children.item(i);
				if (child.getTagName().equals("node"))
					node_names.addElement(child.getAttribute("name"));
			}		
		}
		
		String[] names = new String[node_names.size()];
		for (int i=0 ; i<names.length ; i++)
			names[i] = (String)node_names.elementAt(i);
			
		return names;
	}

	/**
	 * Retrieves a String array with the keys assigned to this node from the
	 * backing store. Please note that, though the AbstractPreferences
	 * method signature defines that this method should throw a BackingStoreException,
	 * this implementation doesn't.
	 * @return a String array with the keys assigned to this node
	 */
	protected String[] keysSpi() throws BackingStoreException {
		Element node = myXMLNode();
		String[] keys = null;
		
		if (node != null) {
			NodeList entries = myEntries();
			keys = new String[entries.getLength()];
			for (int i=0 ; i<entries.getLength() ; i++) {
				Element entry = (Element)entries.item(i);
				keys[i] = entry.getAttribute("key");
			}		
		}			
		return keys;
	}

	/**
	 * Removes a given key from this node on the backing store.
	 * @param key the key to be removed
	 */
	protected void removeSpi(String key) {
		Element node = myXMLNode();
		
		if (node != null) {
			Element map = (Element)node.getElementsByTagName("map").item(0);
			NodeList entries = myEntries();
			for (int i=0 ; i<entries.getLength() ; i++) {
				Element entry = (Element)entries.item(i);
				String node_key = entry.getAttribute("key");
		
				if (node_key.equals(key)) {
					map.removeChild(entry);
				}
			}		
		}
	}

	/**
	 * Retrieves the value associated to a given key from this node from the
	 * backing store.
	 * @param key the key whose value will be retrieved
	 * @return the value associated to the given key, if this node contains such
	 * a pair, or null otherwise
	 */
	protected String getSpi(String key) {
		Element node = myXMLNode();

		if (node != null) {
			NodeList entries = myEntries();
			boolean key_exists = false;					
	
			// test whether or not the node already contains the given key
			for (int j=0 ; j<entries.getLength() ; j++) {
				Element entry = (Element)entries.item(j);
				String node_key = entry.getAttribute("key");
		
				if (node_key.equals(key)) {
					return entry.getAttribute("value");
				}
			}
		}
		return null;
	}

	/**
	 * Sets a key-value pair on this node, on the backing store. If this node
	 * doesn't contain the given key, this pair will be created on the backing
	 * store.
	 * @param key the key to be set
	 * @param the value to be set on the given key
	 */
	protected void putSpi(String key, String value) {
		Element node = myXMLNode();
		
		if (node != null) {
			Element map = (Element)node.getElementsByTagName("map").item(0);
			NodeList entries = myEntries();
			boolean key_exists = false;					
			
			// test whether or not the node already contains the given key
			for (int j=0 ; j<entries.getLength() ; j++) {
				Element entry = (Element)entries.item(j);
				String node_key = entry.getAttribute("key");
				
				if (node_key.equals(key)) {
					entry.setAttribute("value",value);
					key_exists = true;
				}
			}
			
			// if the entry doesn't already exist, create it and append it to this node
			if (!key_exists) {
				Element entry = PreferencesController.getInstance().getXMLDocument().createElement("entry");
				entry.setAttribute("key",key);
				entry.setAttribute("value",value);
				
				map.appendChild(entry);
			}
		}
	}

	/**
	 * Retrieves this node's child with the given name from the backing store. If
	 * such a child doesn't exist, one will be created.
	 * @param name the name of the desired child
	 * @return the desired node, which will have the 'newNode' flag set if it didn't
	 * exist before this method
	 */
	protected AbstractPreferences childSpi(String name) {
		Element node = myXMLNode();
		
		if (node != null) {
			NodeList children = node.getElementsByTagName("node");
			
			for (int i=0 ; i<children.getLength() ; i++) {
				Element child = (Element)children.item(i);
				String child_name = child.getAttribute("name");
				
				if (child_name.equals(name)) 
					return createPreferencesFromElement(child,child_name);
			}
			
			// the child doesn't exist, so one will be created
			AbstractPreferences prefs = new XMLPreferences(this,name);
			Element new_node = PreferencesController.getInstance().getXMLDocument().createElement("node");
			Element map = PreferencesController.getInstance().getXMLDocument().createElement("map");
			
			new_node.appendChild(map);
			new_node.setAttribute("name",name);
			node.appendChild(new_node);

			return prefs;
		}
		return null;
	}
	
	/**
	 * Creates a preferences node from an XML element.
	 * @param child the XML element whose node will be created
	 * @return the newly created preferences node
	 */
	private AbstractPreferences createPreferencesFromElement(Element child, String name) {
		AbstractPreferences prefs = new XMLPreferences(this,name);
		
		NodeList map = child.getElementsByTagName("map");
		NodeList entries = ((Element)map.item(0)).getElementsByTagName("entry");
		
		for (int i=0 ; i<entries.getLength() ; i++) {
			Element entry = (Element)entries.item(i);
			
			prefs.put(entry.getAttribute("key"),entry.getAttribute("value"));
		}
		
		return prefs;
	}

	/**
	 * Retrieves a DOM/XML Element that represents this node on the backing store.
	 * @return
	 */
	private Element myXMLNode() {
		org.w3c.dom.Node root = PreferencesController.getInstance().getXMLDocument().getDocumentElement();
		
		if(root.getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) {
			Element doc_root = (Element)root;
			Element prefs_root = (Element)doc_root.getElementsByTagName("root").item(0);
	
			// checks whether this node is the root
			if (this.name().equals(""))
				return prefs_root;
				
			// fetch the node with the name of this preferences node
			Element my_node = findNode(prefs_root,this.name());
			return my_node;
		}
		
		return null;
	}
	
	/**
	 * Recursively finds a node on the DOM/XML tree.
	 * @param parent the parent of nodes to be searched in a recursive
	 * call of this method
	 * @param name the name of the desired Element
	 * @return the desired Element if it is found, or null otherwise
	 */
	private Element findNode(Element parent, String name) {
		NodeList children = parent.getElementsByTagName("node");
		
		for (int i=0 ; i<children.getLength() ; i++) {
			Element child = (Element)children.item(i);
			String child_name = child.getAttribute("name");
			
			if (child_name.equals(name))
				return child;
			else {
				Element searched = findNode(child,name);
				if (searched != null)
					return searched;
			}
		}
		
		return null;
	}

	/**
	 * Retrieves the DOM nodes that represent this preference's entries from
	 * the backing store.
	 * @return a NodeList with the entries in this preferences node
	 */
	private NodeList myEntries() {
		Element node = myXMLNode();
		
		if (node != null) {
			NodeList map = node.getElementsByTagName("map");
			return ((Element)map.item(0)).getElementsByTagName("entry");
		}
		
		return null;
	}

	/**
	 * Retrieves the String value associated with the given key from this preferences
	 * node, from the backing store.
	 * @param key the key of the desired entry
	 * @param def the default value to be set if the desired pair doesn't yet exist
	 * on the backing store
	 * @return the desired value
	 */
	public String get(String key, String def) {
		String value = getSpi(key);
		
		if (value == null)
			this.put(key,def);
		else
			return value;
			
		return getSpi(key);
	}

	/**
	 * Retrieves the boolean value associated with the given key from this preferences
	 * node, from the backing store.
	 * @param key the key of the desired entry
	 * @param def the default value to be set if the desired pair doesn't yet exist
	 * on the backing store
	 * @return the desired value
	 */
	public boolean getBoolean(String key, boolean def) {
		String value = getSpi(key);
		
		if (value == null) {
			this.putBoolean(key,def);
			return Boolean.getBoolean(getSpi(key));
		}
		else if (value.equals("true"))
			return true;
		else
			return false;
	}

	/**
	 * Retrieves the double value associated with the given key from this preferences
	 * node, from the backing store.
	 * @param key the key of the desired entry
	 * @param def the default value to be set if the desired pair doesn't yet exist
	 * on the backing store
	 * @return the desired value
	 */
	public double getDouble(String key, double def) {
		String value = getSpi(key);
		
		if (value == null) {
			this.putDouble(key,def);
			return Double.parseDouble(getSpi(key));
		}
		else
			return Double.parseDouble(value);
	}

	/**
	 * Retrieves the float value associated with the given key from this preferences
	 * node, from the backing store.
	 * @param key the key of the desired entry
	 * @param def the default value to be set if the desired pair doesn't yet exist
	 * on the backing store
	 * @return the desired value
	 */
	public float getFloat(String key, float def) {
		String value = getSpi(key);
		
		if (value == null) {
			this.putFloat(key,def);
			return Float.parseFloat(getSpi(key));
		}
		else
			return Float.parseFloat(value);
	}

	/**
	 * Retrieves the String value associated with the given key from this preferences
	 * node, from the backing store.
	 * @param key the key of the desired entry
	 * @param def the default value to be set if the desired pair doesn't yet exist
	 * on the backing store
	 * @return the desired value
	 */
	public int getInt(String key, int def) {
		String value = getSpi(key);
		
		if (value == null) {
			this.putInt(key,def);
			return Integer.parseInt(getSpi(key));
		}
		else
			return Integer.parseInt(value);
	}

	/**
	 * Retrieves the long value associated with the given key from this preferences
	 * node, from the backing store.
	 * @param key the key of the desired entry
	 * @param def the default value to be set if the desired pair doesn't yet exist
	 * on the backing store
	 * @return the desired value
	 */
	public long getLong(String key, long def) {
		String value = getSpi(key);
		
		if (value == null) {
			this.putLong(key,def);
			return Long.parseLong(getSpi(key));
		}
		else
			return Long.parseLong(value);
	}

	/**
	 * Retrieves the 'newNode' flag for this node, which indicates whether or not
	 * it has been recently created.
	 * @return true if this node is new, false otherwise
	 */
	public boolean newNode() {
		return newNode;
	}
	
	/**
	 * Sets this node's 'newNode' flag to false, to indicate that it has already
	 * been recognized as a new node and this value is no longer needed, or 
	 *  that this node should no longer be used as a new node
	 */
	public void setNotNewNode() {
		newNode = false;
	}
}

/*
 PreferencesController.java
 */

import java.io.*;
import java.awt.Color;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.*;
import org.xml.sax.SAXException;

import graph_editor.prefs.*;

/**
 * This class is responsible for controlling the user XMLPreferences, which
 * will be used throughout the program to allow persistence of these
 * settings.
 * The tree is composed in the following way: there is a root node that
 * will cluster several property categories. Each category is a different
 * node and will contain several children, each of which represents a 
 * preferences value to the program.
 * Each preference value is a node, child
 * of a category, and will contain two items: a value and a type. This is
 * used to indicate to the program the type of the preference, in case it
 * needs to be known in run-time.
 */
public class PreferencesController {

	/**
	 * The properties category's identifier.
	 */
	public final static String PROPERTIES_CATEGORY  = "Properties";
	/**
	 * The performance category's identifier.
	 */
	public final static String PERFORMANCE_CATEGORY = "Performance";
	/**
	 * The edge color property's identifier.
	 */
	public final static String EDGE_COLOR_PROPERTY = "Edge color";
	/**
	 * The node color property's identifier.
	 */
	public final static String NODE_COLOR_PROPERTY = "Node color";
	/**
	 * The anti-aliasing property's identifier.
	 */
	public final static String ANTIALIASING_PROPERTY = "Anti-aliasing";
	/**
	 * The path in the filesystem to the XMLPreferences file.
	 */
	private final static String PREFERENCES_PATH = ".//user//.preferences";
	/**
	 * A String that will represent an integer type.
	 */
	public final static String TYPE_INT = "int";
	/**
	 * A String that will represent a double type.
	 */
	public final static String TYPE_DOUBLE = "double";
	/**
	 * A String that will represent a boolean type.
	 */
	public final static String TYPE_BOOLEAN = "boolean";
	/**
	 * A String that will represent a color type.
	 */
	public final static String TYPE_COLOR = "color";
	/**
	 * A String that will represent a string type.
	 */
	public final static String TYPE_STRING = "string";
	/**
	 * A String that will represent a type node.
	 */
	public final static String TYPE = "type";
	/**
	 * A String that will represent a value node.
	 */
	public final static String VALUE = "value";
	/**
	 * The unique instance to this class.
	 */
	private static PreferencesController instance;
	/**
	 * The DOM document that will accesses the xml document
	 */
	private static Document prefs_document = null;
	/**
	 * The tree's root node for user XMLPreferences.
	 */
	private static XMLPreferences root_prefs;

	/**
	 * Creates an instance of this class and the root XMLPreferences node.
	 */
	protected PreferencesController() {
	}
	
	/**
	 * Retrieves the unique instance to this class.
	 * @return the unique instance to this class
	 */
	public static PreferencesController getInstance() {
		if (instance == null) {
			instance = new PreferencesController();
			loadPreferences();
		}
		
		return instance;
	}
	
	/**
	 * Adds a new XMLPreferences category to the XMLPreferences tree; each
	 * category will be a leaf in the XMLPreferences tree.
	 * @param name the new XMLPreferences category
	 */
	public void addCategory(String name) {
		XMLPreferences new_node = (XMLPreferences)root_prefs.node(name);
	}
	
	/**
	 * Puts an int value into a XMLPreferences category.
	 * @param category_name the name of the category
	 * @param key the key of the new value
	 * @param value the default value
	 */
	public void putInt(String category_name, String key, int value) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name).node(key);
		
		node.put(TYPE,TYPE_INT);
		node.putInt(VALUE,value);
	}
	
	/**
	 * Puts a double value into a XMLPreferences category.
	 * @param category_name the name of the category
	 * @param key the key of the new value
	 * @param value the default value
	 */
	public void putDouble(String category_name, String key, double value) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name).node(key);
		
		node.put(TYPE,TYPE_DOUBLE);
		node.putDouble(VALUE,value);
	}
	
	/**
	 * Puts a boolean value into a XMLPreferences category.
	 * @param category_name the name of the category
	 * @param key the key of the new value
	 * @param value the default value
	 */
	public void putBoolean(String category_name, String key, boolean value) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name).node(key);
		
		node.put(TYPE,TYPE_BOOLEAN);
		node.putBoolean(VALUE,value);
	}
	
	/**
	 * Puts a String value into a XMLPreferences category.
	 * @param category_name the name of the category
	 * @param key the key of the new value
	 * @param value the default value
	 */
	public void put(String category_name, String key, String value) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name).node(key);
		
		node.put(TYPE,TYPE_STRING);
		node.put(VALUE,value);
	}
	
	/**
	 * Puts a Color value into a XMLPreferences category.
	 * @param category_name the name of the category
	 * @param key the key of the new value
	 * @param value the default value
	 */
	public void putColor(String category_name, String key, Color value) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name).node(key);
		
		node.put(TYPE,TYPE_COLOR);
		node.putInt(VALUE,value.getRGB());
	}
	
	/**
	 * Retrieves the int value in the specified category; the default value
	 * will be set if the category isn't found.
	 * @param category_name the name of the category
	 * @param key the key of the value
	 * @param def the default value
	 * @return the desired value, if it is found, or the default otherwise
	 */
	public int getInt(String category_name, String key, int def) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name + "/" + key);
		
		if (node.newNode()) {
			this.putInt(category_name,key,def);
			node.setNotNewNode();
		}
		
		return node.getInt(VALUE,def);
	}
	
	/**
	 * Retrieves the double value in the specified category; the default value
	 * will be set if the category isn't found.
	 * @param category_name the name of the category
	 * @param key the key of the value
	 * @param def the default value
	 * @return the desired value, if it is found, or the default otherwise
	 */
	public double getDouble(String category_name, String key, double def) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name + "/" + key);
		
		if (node.newNode()) {
			this.putDouble(category_name,key,def);
			node.setNotNewNode();
		}
		
		return node.getDouble(VALUE,def);
	}
	
	/**
	 * Retrieves the boolean value in the specified category; the default value
	 * will be set if the category isn't found.
	 * @param category_name the name of the category
	 * @param key the key of the value
	 * @param def the default value
	 * @return the desired value, if it is found, or the default otherwise
	 */
	public boolean getBoolean(String category_name, String key, boolean def) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name + "/" + key);
		
		if (node.newNode()) {
			this.putBoolean(category_name,key,def);
			node.setNotNewNode();
		}
		
		return node.getBoolean(VALUE,def);
	}
	
	/**
	 * Retrieves the String value in the specified category; the default value
	 * will be set if the category isn't found.
	 * @param category_name the name of the category
	 * @param key the key of the value
	 * @param def the default value
	 * @return the desired value, if it is found, or the default otherwise
	 */
	public String get(String category_name, String key, String def) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name + "/" + key);
		
		if (node.newNode()) {
			this.put(category_name,key,def);
			node.setNotNewNode();
		}
		
		return node.get(VALUE,def);
	}
	
	/**
	 * Retrieves the Color value in the specified category; the default value
	 * will be set if the category isn't found.
	 * @param category_name the name of the category
	 * @param key the key of the value
	 * @param def the default value
	 * @return the desired value, if it is found, or the default otherwise
	 */
	public Color getColor(String category_name, String key, Color def) {
		XMLPreferences node = (XMLPreferences) root_prefs.node(category_name + "/" + key);

		if (node.newNode()) {
			this.putColor(category_name,key,def);
			node.setNotNewNode();
		}
			
		return new Color(node.getInt(VALUE,def.getRGB()));
	}
	
	/**
	 * Flushes the XMLPreferences to the output file for persistence.
	 */
	public void savePreferences() {
		try {
			File pref_file = new File(PREFERENCES_PATH);
			
			if(!pref_file.exists())
				pref_file.createNewFile();
				
			// save the XML tree to the XMLPreferences file
			DOMSource source = new DOMSource(prefs_document); 
			StreamResult sr = new StreamResult(pref_file); 
			Transformer transformer = TransformerFactory.newInstance().newTransformer(); 
			transformer.transform(source, sr);
		}
		catch(IOException exc) {
			exc.printStackTrace();
		} catch (TransformerConfigurationException exc) {
			exc.printStackTrace();
		} catch (TransformerFactoryConfigurationError exc) {
			exc.printStackTrace();
		} catch (TransformerException exc) {
			exc.printStackTrace();
		}
	}
	
	/**
	 * Loads the existing XMLPreferences file into the program's XMLPreferences
	 * tree; if the file does not exist, an IOException will be caught and
	 * no settings will be imported.
	 * @return the DOM Document to be used by all the preferences nodes
	 */
	public static Document loadPreferences() {
		File xml_prefs = new File(PREFERENCES_PATH);

		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			factory.setValidating(false);
			DocumentBuilder builder = factory.newDocumentBuilder();
			
			if (xml_prefs.exists()){
				prefs_document = builder.parse(xml_prefs);
				buildPreferencesFromDocument();
			}	
			else {
				prefs_document = builder.newDocument();
				
				// TODO set DOCTYPE
				
				// create root node and its map
				Element prefs = prefs_document.createElement("preferences");
				prefs.setAttribute("EXTERNAL_XML_VERSION","1.0");
				prefs_document.appendChild(prefs);
				
				Element root = prefs_document.createElement("root");
				root.setAttribute("type","user");
				Element root_map = prefs_document.createElement("map");
				root.appendChild(root_map);
				
				prefs.appendChild(root);
				
				root_prefs = new XMLPreferences(null,"");
			}
		}catch (ParserConfigurationException e){
			  e.printStackTrace();
		}catch (SAXException e) {
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		}
		
		return prefs_document;
	}
	
	/**
	 * Starts the creation of the preferences tree from the DOM/XML Document.
	 * This method will retrieve the 'root' Element from the DOM Document and
	 * call the recursive 'buildPreferences' method upon it to start the
	 * creation of the preferences tree.
	 */
	private static void buildPreferencesFromDocument() {
		Element doc_root = (Element)(prefs_document.getElementsByTagName("root").item(0));
		buildPreferences(doc_root,null);
	}

	/**
	 * Recursively builds the preferences tree from the DOM Element nodes. This method
	 * should be called initially for the 'root' Element, since it will build
	 * an XMLPreferences instance for the given node and call itself upon its
	 * children.
	 * @param node the DOM Element node for which an XMLPreferences instance
	 * will be created
	 * @param parent the parent of the node
	 */
	private static void buildPreferences(Element node,XMLPreferences parent) {
		NodeList children = node.getChildNodes();
		XMLPreferences prefs = null;
		
		if (parent != null)
			prefs = (XMLPreferences)parent.node(node.getAttribute("name"));
		else
			prefs = new XMLPreferences(null,"");
		
		if (children.getLength() != 0) {
			Element map = (Element)children.item(0);
			NodeList entries = map.getElementsByTagName("entry");
			
			for (int i=0 ; i<entries.getLength() ; i++) {
				Element entry = (Element)entries.item(0);
				prefs.put(entry.getAttribute("key"),entry.getAttribute("value"));
			}
			
			for (int i=1 ; i<children.getLength() ; i++)
				buildPreferences((Element)children.item(i),prefs);
		}
		
		prefs.setNotNewNode();
		if (parent == null)
			root_prefs = prefs;
	}

	/**
	 * Retrieves the root node in the XMLPreferences tree.
	 * @return the root node in the XMLPreferences tree
	 */
	public XMLPreferences getRoot() {
		return root_prefs;
	}
	
	/**
	 * Retrieves the DOM document for the Preferences XML tree.
	 * @return the DOM document for the Preferences XML tree
	 */
	public Document getXMLDocument() {
		return prefs_document;
	}

	/**
	 * 
	 * @param doc
	 */
	public void setXMLDocument(Document doc) {
		prefs_document = doc;
	}
}