source: trunk/gli/src/org/greenstone/gatherer/valuetree/GValueNode.java@ 5672

/**
 *#########################################################################
 *
 * 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.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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.
 *
 * <BR><BR>
 *
 * 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.valuetree;

/**
 * Title:        The Gatherer<br>
 * Description:  The Gatherer: a tool for gathering and enriching digital collections.<br>
 * Copyright:    Copyright (c) 2001<br>
 * Company:      The University of Waikato<br>
 * First Coded:  20/06/02
 * Revised:<br>
 * @author John Thompson, Greenstone Digital Libraries
 * @version 2.1
 */

import java.util.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.msm.MSMUtils;
import org.greenstone.gatherer.util.Codec;
import org.greenstone.gatherer.util.StaticStrings;
import org.greenstone.gatherer.util.Utility;
import org.w3c.dom.*;

/** This class is instantiated using a metadata element. From this parent element, which refers to a specific Element in the mds DOM model, the AssignedValues child is used as the root of a tree data-structure encompassing all of the nodes within the AssignedValues tree. This class also provide methods for adding, updating and removing nodes within this tree, as well as implementing all of the methods necessary for this node to be used as the basis of a tree model.
 */
public class GValueNode 
    extends DefaultMutableTreeNode {

   static final public int DOM = 0;
   static final public int GREENSTONE = 1;
   static final public int TEXT = 2;
   
    private String element_name = null;
    private String default_value = null;

    public GValueNode(Element element) {
    this.children = null;
    this.userObject = element;
    this.default_value = null;
    }

    public GValueNode(String element_name, String default_value) {
    this.element_name = element_name;
    this.default_value = default_value;
    }

    /** Compares two GValueNodes for ordering by using the String.compareTo method.
     * @param sibling The <strong>Object</strong> representing the GValueNode we are comparing ourselves to.
     * @return An <i>int</i> indicating the ordering. The value is less than zero if we are before the parameter object, zero if we are equal and greater than zero if we preceed sibling.
     */
    public int compareTo(Object sibling) {
    return toString().compareTo(sibling.toString());
    }

    /** Determine if this tree node contains a child with a matching value.
     * @param value The value we are attempting to match, as a <strong>String</strong>.
     * @return <i>true</i> if there is a matching child node, <i>false</i> otherwise.
     */
    public boolean containsValue(String value) {
    if(default_value != null) {
        return false;
    }
    return getValue(value) != null;
    }

    /** Returns an enumeration of the child nodes.
     * @return An <strong>Enumeration</strong> containing the child nodes.
     */
    public Enumeration children() {
    if(default_value != null) {
        return null;
    }
    if(children == null) {
        map();
    }
    return children.elements();
    }
    public boolean equals(Object other) {
    return compareTo(other) == 0;
    }

    public GValueNode get(int index) {
    GValueNode result = null;
    if(children != null) {
        result = (GValueNode) children.get(index);
    }
    return result;
    }

    public String getAlias() {
    // Attempt to retrieve a child node named Alias
    Element element = (Element) userObject;
    for(Node pos_node = element.getFirstChild(); pos_node != null; pos_node = pos_node.getNextSibling()) {
        // And if we find such a node 
        if(pos_node.getNodeName().equals("Alias")) {
        // Retrieve its text node
        for(Node pos_text = pos_node.getFirstChild(); pos_text != null; pos_text = pos_text.getNextSibling()) {
            // When we find the node return its value
            if(pos_text.getNodeName().equals("#text")) {
            return pos_text.getNodeValue();
            }
        }
        }
    }         
    return "";
    }

    public String getAlias(String index) {
    return index;
    }

    /** Returns <I>true</I> if the reciever allows children. */
    public boolean getAllowsChildren() {
    return true;
    }

    /** Returns the child <I>TreeNode</I> at index <I>childIndex</I>.*/
    public TreeNode getChildAt(int index) {
    if(default_value != null) {
        return this;
    }
    if(children == null) {
        map();
    }
    return (GValueNode) children.get(index);
    }

    /** Returns the number of children <I>TreeNode</I>s the reciever contains. */
    public int getChildCount() {
    int size = 0;
    if(default_value != null) {
        size = 0;
    }
    if(children == null) {
        map();
    }
    return children.size();
    }

    public Element getElement() {
    return (Element) userObject;
    }

    /** Return the path to this node within the value tree model.
     * @return A <strong>String</strong> representing the path, ie "Titles\Modern\The Green Mile"
     */
    public String getFullPath(boolean as_text) {
    if(default_value != null) {
        return default_value;
    }
    StringBuffer path = new StringBuffer(toString());
    GValueNode node = (GValueNode) getParent();
    while(node != null && !node.getElement().getNodeName().equalsIgnoreCase("AssignedValues")) {
        path.insert(0, StaticStrings.ESCAPE_STR + StaticStrings.ESCAPE_STR);
        path.insert(0, node.toString());
        node = (GValueNode) node.getParent();
    }
    if(as_text) {
        return Codec.transform(path.toString(), Codec.GREENSTONE_TO_TEXT);
    }
    else {
        return path.toString();
    }
    }

    /** Returns the index of <I>node</I> in the recievers children. If the
     * reciever does not contain <I>node</I>, <I>-1</I> will be returned. */
    public int getIndex(TreeNode node) {
    if(default_value != null) {
        return 0;
    }
    if(children == null) {
        map();
    }
    return children.indexOf(node);
    }

    public String getMetadataElementName() {
    if(default_value != null) {
        return element_name;
    }
    GValueNode node = this;
    while(node != null && !node.getElement().getNodeName().equalsIgnoreCase("AssignedValues")) {
        node = (GValueNode)node.getParent();
    }
    if(node != null) {
        return node.getElement().getAttribute("element");
    }
    return null;
    }

   public GValueNode getValue(String value) {
      ///ystem.err.println("GValueNode.getValue(" + value + ")");
      if(default_value != null) {
     return this;
      }
      if(children == null) {
     map();
      }
      for(int i = 0; i < children.size(); i++) {
     GValueNode child = (GValueNode) children.get(i);
     ///ystem.err.println("Comparing value and '" + child.toString(GValueNode.DOM));
     if(child.toString(GValueNode.DOM).equalsIgnoreCase(value)) {
        return child;
     }
      }
      return null;
   }

    /** Adds <I>child</I> to the receiever at <I>index</I>. <I>child</I> will
     * be messaged with setParent().
     */
    public void insert(MutableTreeNode child, int index) {
    if(default_value != null) {
        return;
    }
    if(index >= children.size()) {
        // Append to children.
        children.add(child);
        // And to document
        getElement().appendChild(((GValueNode)child).getElement());
    }
    else {
        GValueNode sibling = (GValueNode) children.get(index);
        // Insert in children
        children.add(index, child);
        // And in document
        getElement().insertBefore(((GValueNode)child).getElement(), sibling.getElement());
    }
    child.setParent(this);
    }

    /** Returns <I>true</I> if the reciever is a leaf. */
    public boolean isLeaf() {
    if(default_value != null || getChildCount() > 0) {
        return false;
    }
    return true;
    }

    /** Ensure that the children nodes of this tree are instantiated, and record the initial mappings for legacy sake. 
     * @param mapping A <strong>HashMap</strong> into which to write the initial mappings.
     * @param prefix The prefix to use for indexes, as a <strong>String</strong>.
     */
    public void map(HashMap mapping, String prefix) {
    if(default_value != null) {
        return;
    }
    children = new Vector();
    if(prefix.length() > 0) {
        prefix = prefix + ".";
    }
    int i = 1;
    for(Node node = getElement().getFirstChild(); node != null; node = node.getNextSibling()) {
        if(node.getNodeName().equals("Subject")) {
        GValueNode child = new GValueNode((Element)node);
        child.setParent(this);
        children.add(child);
        String index = prefix + i;
        mapping.put(index, child);
        child.map(mapping, index);
        i++;
        }
    }
    }

    public void setAlias(String alias) {
    setNodeValue("Alias", alias);
    }

    /** Resets the user object of the reciever to <I>object</I>. */
    public void setUserObject(Object object) {
    // Can't ever change Elements from here. Have to use editor. */       
    }

    public void setValue(String value) {
    setNodeValue("Value", value);
    }

    public int size() {
    int size = 0;
    if(children != null) {
        size = children.size();
    }
    return size;
    }

    /** Returns a <I>String</I> representation of the reciever. If this
     * happens to be the AssignedValues 'root' then we do something slightly
     * different, otherwise we return the value of the <I>#Text</I> child of 
     * the <I>Value</I> of this <I>Subject</I> node!
     */
    public String toString() {
    return toString(GValueNode.TEXT);
    }
    
    public String toString(int decode_type) {
    if(default_value != null) {
        return default_value;
    }
    Element element = getElement();
    String name = element.getNodeName();
    String result = null;
    if(name.equals("Subject")) {
       result = MSMUtils.getValue(element);
       switch(decode_type) {
          case GValueNode.GREENSTONE:
         // We want this as greenstone format
         ///ystem.err.print(result);
         result = Codec.transform(result, Codec.DOM_TO_GREENSTONE);
         ///ystem.err.println(" -> D2G decode -> " + result);
         break;
          case GValueNode.TEXT:
         ///ystem.err.print(result);
         result = Codec.transform(result, Codec.DOM_TO_TEXT);
         ///ystem.err.println(" -> D2T decode -> " + result);
         break;
          default:
         ///ystem.err.println(result + " -> nothing to do.");
       }
    }
    else if(name.equals("AssignedValues")) {
        result = getMetadataElementName();
    }
    return result;
    }

    private void map() {
    children = new Vector();
    for(Node node = getElement().getFirstChild(); node != null; node = node.getNextSibling()) {
        if(node.getNodeName().equals("Subject")) {
        GValueNode child = new GValueNode((Element)node);
        child.setParent(this);
        children.add(child);
        }
    }
    }

    /** Removes the child at index from the receiver. */
    public void remove(int index) {
    remove((MutableTreeNode)getChildAt(index));
    }
     
    /** Removes node from the receiver. */
    public void remove(MutableTreeNode node) {
    children.remove(node);
    node.setParent(null);
    // Remove from DOM
    Element child_element = ((GValueNode)node).getElement();
    Node parent_node = child_element.getParentNode();
    parent_node.removeChild(child_element);
    }
          
    /** Removes the receiver from its parent. */
    public void removeFromParent() {
    if(parent != null) {
        parent.remove(this);
    }
    }

    private void setNodeValue(String name, String value) {
    boolean found = false;
    // Attempt to retrieve a child node named name
    Element element = (Element) userObject;
    for(Node pos_node = element.getFirstChild(); pos_node != null; pos_node = pos_node.getNextSibling()) {
        // And if we find such a node 
        if(pos_node.getNodeName().equals(name)) {
        // And the new value is non-null, retrieve its text node and change it.
        if(value != null) {
            for(Node pos_text = pos_node.getFirstChild(); pos_text != null; pos_text = pos_text.getNextSibling()) {
            // When we find the node...
            if(pos_text.getNodeName().equals("#text")) {
                pos_text.setNodeValue(value);
            }
            }
        }
        // Otherwise remove the node altogether
        else {
            element.removeChild(pos_node);
        }
        found = true;
        }
    }
    // Otherwise if no such node exists add it.
    if(!found && value != null) {
        Document document = element.getOwnerDocument();
        Node new_node = document.createElementNS("", name);
        element.appendChild(new_node);
        Node new_text = document.createTextNode(value);
        new_node.appendChild(new_text);
        new_text = null;
        new_node = null;
    }
    // Done.
    element = null;
    return;
    }
}