hierarchial collection of graphic element

Hi,
 I'm planning an API for a hierarchy of graphical
elements to be drawn in a java.awt.Graphics2D context.
Since my hierarchy is a collection of similar elements
I hope to reuse the API from the Java Collections
framework to implement the construction, navigation,
and maintenance facets of my API. Toward this end I have
come up with the following basic API, and I hope you
will look it over and comment(does it seem to make any sense?).

The basic design goals concerning the construction,
navigation and maintenance facets of my API are listed here:

This collection of elements will be hierarchial.

An Element in my collection is a leaf in the hierarchy
tree, it cannot contain other Elements. Each Element has
a reference to zero or one parent Element.

A CompoundElement is an Element, but it may contain other
Elements or CompoundElements.
(This part sounds silly to me too!)

Each CompoundElement is an 'ordered set'.
It is a set in that it contains no nulls or duplicate
elements, and it maintains an order thus it may also be
considered a list.
(This part sounds odd but not silly to me.)

The order of the set amounts to 'insertion order' from a
construction perspective, or 'stacking order' from a
graphical perspective. Elements in a CompoundElement
may be inserted, removed, reordered, reparented(moved).

Thanks,
Jeff Higgins

/**
 * The Element interface extends the java.awt.Shape
 * interface so that Element objects may be manipulated
 * within the java.awt.* packages. The Element
 * interface extends java.util.List<Element> so as to
 * facilitate the insertion, removal, reordering, and
 * reparenting of Elements and CompoundElements within
 * a CompoundElement only.
 * List methods in the Element implementing classes
 * will throw UnSupportedOperationExceptions.
 *
 * An abstract Element is implemented in BasicElement.
 *
 */
interface Element
extends Shape, List<Element> {

  Element getParent();
  void setParent (int index, Element parent);
}

/**
 * The abstract class CompoundElement implements
 * a base class representing a hierarchial collection
 * of Elements(a basic java.awt.Shape) and
 * CompoundElements(a more complex java.awt.Shape).
 * CompoundElement implements the NavigableSet interface,
 * which in turn implements the SortedSet interface.
 * The CompoundElement is thus a ordered set by virtue
 * of it's backing store ElementList, an ArrayList<Element>
 * by implementation.
 */
public abstract class CompoundElement
implements Element, NavigableSet<Element> {

  private ElementList elements;
  private Element parent;

  // *******************************
  // From Element
  // *******************************

  @Override
  public Element getParent() {
    return parent;
  }

  @Override
  public void setParent(int index, Element newParent) {
    if( null == newParent ||
        this == newParent ||
        newParent == parent )
      return;
    if(this.parent.contains(this)) {
      int idx = parent.indexOf(this);
      this.parent.remove(this);
      newParent.add(idx, this);
      parent = newParent;
    }
  }

  // TODO Methods from NavigableSet

  // *******************************
  // From SortedSet via NavigableSet
  // *******************************

  @Override
  public Element first() {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public Element last() {
    // TODO Auto-generated method stub
    return null;
  }

  @Override
  public Comparator<? super Element> comparator() {
    return new ElementComparator();
  }

  class ElementComparator
  implements Comparator<Element> {

    @Override
    public int compare(Element e0, Element e1) {
      if(!elements.contains(e0) || !elements.contains(e1))
        throw new IllegalArgumentException();
      if(elements.indexOf(e0) < elements.indexOf(e1))
        return -1;
      if(elements.indexOf(e0) > elements.indexOf(e1))
        return 1;
      return 0;
    }
  }

}

public class ElementList
extends AbstractList<Element> {

  private List<Element> elements;

  public ElementList() {
    elements = new ArrayList<Element>(0);
  }

  @Override
  public int size() {
    return elements.size();
  }

  @Override
  public Element get(int index) {
    return elements.get(index);
  }

  @Override
  public Element set(int index, Element element) {
    elements.set(index, element);
    return elements.remove(index+1);
  }

  @Override
  public void add(int index, Element element) {
    if(null != element && !elements.contains(element))
      elements.add(element);
  }

  @Override
  public Element remove(int index) {
    return elements.remove(index);
  }
}