source: trunk/gli/src/org/greenstone/gatherer/mem/MEMNode.java@ 8236

/**
 *#########################################################################
 *
 * 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.mem;

import java.io.*;
import java.util.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Configuration;
import org.greenstone.gatherer.DebugStream;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.collection.BasicCollectionConfiguration;
import org.greenstone.gatherer.mem.AttributeTableModel;
import org.greenstone.gatherer.msm.ElementWrapper;
import org.greenstone.gatherer.msm.MetadataSet;
import org.greenstone.gatherer.msm.MetadataSetManager;
import org.greenstone.gatherer.util.Utility;
import org.w3c.dom.*;
/**
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3
 */
public class MEMNode
    extends DefaultMutableTreeNode {
    private AttributeTableModel model = null;
    private int type = 0;
    private String text = null;
    static final public int COLLECTION = 0;
    static final public int ELEMENT    = 1;
    static final public int PROFILER   = 2;
    static final public int ROOT       = 3; 
    static final public int SET        = 4;

    public MEMNode() {
    this.type = ROOT;
    }

    public MEMNode(int type, Object object, MEMNode parent) {
    this.userObject = object;
    this.parent = parent;
    this.type = type;
    this.text = null;
    }

    public Enumeration children() {
    if(children == null) {
        mapChildren();
    }         
    return children.elements();
    }

    public boolean getAllowsChildren() {
    return true;
    }

    public TreeNode getChildAt(int index) {
    if(children == null) {
        mapChildren();
    }
    return (TreeNode) children.get(index);
    }
    public int getChildCount() {
    if(children == null) {
        mapChildren();
    }
    return children.size();
    }
    public ElementWrapper getElement() {
    ElementWrapper result = null;
    if(type == ELEMENT) {
        result = (ElementWrapper) userObject;
    }
    return result;
    }
    public int getIndex(TreeNode node) {
    if(children == null) {
        mapChildren();
    }
    return children.indexOf(node);
    }
    public AttributeTableModel getModel() {
    return model;
    }
    public TreeNode getParent() {
    return parent;
    }
    public MetadataSet getSet() {
    MetadataSet result = null;
    if(type == SET) {
        result = (MetadataSet) userObject;
    }
    return result;
    }
    public int getType() {
    return type;
    }
    public boolean isLeaf() {
    if(children == null) {
        mapChildren();
    }
    return children.size() == 0;
    }
    public void setModel(AttributeTableModel model) {
    this.model = model;
    }

    public String toString() {
    if(text == null) {
        if(userObject != null) {
        if(userObject instanceof ElementWrapper) {
            text = ((ElementWrapper)userObject).getName();
        }
        // In the case of a 'collection' source path we need to examine the path closely. If it is a descendant of the greenstone collections path then supress everything but the collection name
        else if(type == COLLECTION) {
            try {
            boolean is_descendant = false;
            File source_path = new File((String)userObject);
            File collect_path;
            if (Gatherer.GS3) {
                collect_path = new File(Utility.getCollectDir(Configuration.gsdl3_path, Configuration.site_name));
            }  else {
                collect_path = new File(Utility.getCollectDir(Configuration.gsdl_path));
            }
            File current_path = source_path;
            while(!is_descendant && current_path != null) {
                is_descendant = current_path.equals(collect_path);
                current_path = current_path.getParentFile();
            }
            current_path = null;
            collect_path = null;
            // We've either found we are a descendant, or run out of path
            if(is_descendant) {
                // Create a basic config class
                File config_file = new File(source_path, Utility.CONFIG_FILE);
                if (config_file.exists()) {
                BasicCollectionConfiguration config = new BasicCollectionConfiguration(config_file);
                text = config.toString();
                config = null;
                } else {
                text = source_path.getAbsolutePath();
                }
                config_file = null;
            }
            else {
                text = source_path.getAbsolutePath();
            }
            }
            catch(Exception exception) {
            DebugStream.println("Exception in MEMNode.toString() - exception is unexpected");
            DebugStream.printStackTrace(exception);
            text = userObject.toString();
            }
        }
        else {
            text = userObject.toString();
        }
        }
        else {
        text = "error";
        }
    }
    return text;
    }
    private void mapChildren() {
    ///ystem.err.println("Mapping the children of " + this);
    children = new Vector();
    // How we build children depends on the node type
    switch(type) {
    case PROFILER: // Add the collections as children
        ArrayList a = Gatherer.c_man.msm.profiler.getCollections();
        for(int i = 0; i < a.size(); i++) {
        children.add(new MEMNode(COLLECTION, a.get(i), this));
        }
        a = null;
        break;
    case ROOT:
        Vector v = Gatherer.c_man.msm.getSets();
        for(int i = 0; i < v.size(); i++) {
        children.add(new MEMNode(SET, v.get(i), this));
        }
        v = null;
        // Add the profile set.
        children.add(new MEMNode(PROFILER, Dictionary.get("MEM.Profiles"), this));
        break;
    case SET: // Add the elements as children
        MetadataSet set = (MetadataSet) userObject;
        NodeList elements = set.getElements();
        set = null;
        for(int i = 0; i < elements.getLength(); i++) {
        children.add(new MEMNode(ELEMENT, new ElementWrapper((Element) elements.item(i)), this));
        }
        elements = null;
        break;
    case COLLECTION:
    case ELEMENT:
    default:
    }
    }
}