source: trunk/gli/src/org/greenstone/gatherer/cdm/DOMProxyListModel.java@ 8266

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

import java.util.*;
import javax.swing.*;
import org.w3c.dom.*;

/** This class provides ListModel like access to a list of nodes within a DOM model.
 * @author John Thompson, Greenstone Digital Library, University of Waikato
 * @version 2.3d
 */
public class DOMProxyListModel
    extends AbstractListModel {
    protected Element root;
    private DOMProxyListEntry class_type;
    private HashMap cache = new HashMap();
    private NodeList children = null;
    private String tag_name;

    /** Constructor.
     * @param root the Element at the root of the subtree to be searched for appropriate child elements
     * @param tag_name the name of appropriate elements as a String
     * @param class_type the type of object to wrap the elements returned in, as a DOMProxyListEntry
     */
    public DOMProxyListModel(Element root, String tag_name, DOMProxyListEntry class_type) {
    this.class_type = class_type;
    this.root = root;
    this.tag_name = tag_name;
    }

    /** Used to add an element into the underlying dom, and fire the appropriate repaint events. This version always adds the new element at the very head of the DOM. */
    public synchronized void add(DOMProxyListEntry entry) {
    Element element = entry.getElement();
    if(root.hasChildNodes()) {
        Node sibling = root.getFirstChild();
        root.insertBefore(element, sibling);
        sibling = null;
    }
    else {
        root.appendChild(element);
    }
    element = null;
    // Regardless fire update event
    cache.clear();
    fireIntervalAdded(this, 0, 0);
    }

    /** Used to add an element into the underlying dom, and fire the appropriate repaint events.
     * @param index the index where the element should be inserted (relative of the other elements in this proxy list)
     * @param entry the <strong>DOMProxyListEntry</strong> to be inserted
     */
    public synchronized void add(int index, DOMProxyListEntry entry) {
    ///atherer.println("Add entry at " + index + " where size = " + getSize());
    Element element = entry.getElement();
    // retrieve the node where we want to insert
    if(index < children.getLength()) {
        Node sibling = children.item(index);
        // Find the parent node
        Node parent_node = sibling.getParentNode();
        parent_node.insertBefore(element, sibling);
        sibling = null;
    }
    // If the index is too large, we are adding to the end of our list of entries. However you have to remember that this list is only a viewport on the entire DOM so there might be entries following this group that we actually want to insert before (not append at the very end!)
    else {
        // Retrieve the currently last entry
        index = children.getLength() - 1;
        Node sibling = null;
        Node parent_node = null;
        if(index >= 0) {
        sibling = children.item(index);
        parent_node = sibling.getParentNode();
        sibling = sibling.getNextSibling();
        }
        if(sibling != null && parent_node != null) {
        parent_node.insertBefore(element, sibling);
        }
        // Add to the root node
        else {
        index = 0;
        root.appendChild(element);
        }
    }
    // Regardless fire update event
    cache.clear();
    fireIntervalAdded(this, index, index);
    }

    /** Used to add an element into the underlying dom, and fire the appropriate repaint events. This version inserts the new entry immediately -after- the given entry in the DOM.
     * @param entry the DOMProxyListEntry to be inserted
     * @param proceeding_entry the DOMProxyListEntry immediately before where we want the new entry
     */
    public synchronized void addAfter(DOMProxyListEntry entry, DOMProxyListEntry proceeding_entry) {
    Element element = entry.getElement();
    Element proceeding_sibling = proceeding_entry.getElement();
    Node parent_node = proceeding_sibling.getParentNode();
    Node following_sibling = proceeding_sibling.getNextSibling();
    if(following_sibling != null) {
        parent_node.insertBefore(element, following_sibling);
    }
    else {
        parent_node.appendChild(element);
    }
    // Regardless fire update event
    cache.clear();
    int index = indexOf(proceeding_entry) + 1;
    fireIntervalAdded(this, index, index);
    }

    /** Used to add an element into the underlying dom, and fire the appropriate repaint events. This version inserts the new entry immediately -before- the given entry in the DOM.
     * @param entry the DOMProxyListEntry to be inserted
     * @param following_entry the DOMProxyListEntry immediately after where we want the new entry
     */
    public synchronized void addBefore(DOMProxyListEntry entry, DOMProxyListEntry following_entry) {
    Element element = entry.getElement();
    Element following_sibling = following_entry.getElement();
    Node parent_node = following_sibling.getParentNode();
    parent_node.insertBefore(element, following_sibling);
    // Regardless fire update event
    cache.clear();
    int index = indexOf(entry);
    fireIntervalAdded(this, index, index);
    }

    public synchronized void add(Node parent, DOMProxyListEntry entry, Node sibling) {
    Element child = entry.getElement();
    if(sibling != null) {
        parent.insertBefore(child, sibling);
    }
    else {
        parent.appendChild(child);
    }
    cache.clear();
    int index = indexOf(entry);
    fireIntervalAdded(this, index, index);
    }

    /** Used to add an element into the underlying dom, and fire the appropriate repaint events. This version always adds the new element at the end of the children. */
    public synchronized void append(DOMProxyListEntry entry) {
    Element element = entry.getElement();
    root.appendChild(element);
    element = null;
    // Regardless fire update event
    cache.clear();
    fireIntervalAdded(this, 0, 0);
    }
   
    public synchronized ArrayList children() {
    ArrayList child_list = new ArrayList();
    int child_count = children.getLength();
    for(int i = 0; i < child_count; i++) {
        child_list.add(getElementAt(i));
    }
    return child_list;
    }

    public synchronized boolean contains(Object entry) {
    boolean found = false;
    int size = getSize();
    for(int i = 0; !found && i < size; i++) {
        DOMProxyListEntry sibling = (DOMProxyListEntry) getElementAt(i);
        if(sibling.equals(entry)) {
        found = true;
        }
    }
    return found;
    }

    public synchronized Object getElementAt(int index) {
    Object object = cache.get(new Integer(index));
    if(object == null) {
        // Retrieve the required element
        Element element = (Element) children.item(index);
        // Now wrap it in the object of the users choice
        object = class_type.create(element);
        cache.put(new Integer(index), object);
    }
    return object;
    }

    public synchronized int indexOf(DOMProxyListEntry entry) {
    Element element = entry.getElement();
    int children_length = children.getLength();
    for(int i = 0; i < children_length; i++) {
        Node node = children.item(i);
        if(element == node) {
        return i;
        }
    }
    return -1;
    }

    public synchronized int getSize() {
    if(children == null) {
        children = root.getElementsByTagName(tag_name);
    }
    return children.getLength();
    }

    public synchronized void refresh() {
    fireContentsChanged(this, 0, getSize());
    }

    public synchronized void refresh(DOMProxyListEntry entry) {
    int index = indexOf(entry);
    fireContentsChanged(this, index, index);
    }

    public synchronized void remove(DOMProxyListEntry entry) {
    remove(indexOf(entry));
    } 

    public synchronized void remove(int index) {
    // Retrieve the required element
    Node node = children.item(index);
    // Find its parent
    Node parent_node = node.getParentNode();
    // Now remove it
    parent_node.removeChild(node);
    // Refresh model
    cache.clear();
    fireIntervalRemoved(this, index, index);
    }

    /** Changes the 'root' element that this list sources its information from. 
     * @param  root the new root Element
     */
    public synchronized void setRoot(Element root) {
    this.children = null;
    cache.clear();
    this.root = root;
    }
}