diff --git a/samples/showcase/src/com/google/gwt/sample/showcase/client/content/cell/ContactTreeViewModel.java b/samples/showcase/src/com/google/gwt/sample/showcase/client/content/cell/ContactTreeViewModel.java
index e3c3f75..6df28dc 100644
--- a/samples/showcase/src/com/google/gwt/sample/showcase/client/content/cell/ContactTreeViewModel.java
+++ b/samples/showcase/src/com/google/gwt/sample/showcase/client/content/cell/ContactTreeViewModel.java
@@ -102,7 +102,7 @@
     public int compareTo(LetterCount o) {
       return (o == null) ? -1 : (firstLetter - o.firstLetter);
     }
- 
+
     @Override
     public boolean equals(Object o) {
       return compareTo((LetterCount) o) == 0;
@@ -201,6 +201,9 @@
       @Override
       public void onBrowserEvent(Element parent, ContactInfo value, Object key,
           NativeEvent event, ValueUpdater<ContactInfo> valueUpdater) {
+        // Make sure that the composition cells see the event.
+        super.onBrowserEvent(parent, value, key, event, valueUpdater);
+
         if ("keyup".equals(event.getType())
             && event.getKeyCode() == KeyCodes.KEY_ENTER) {
           selectionModel.setSelected(value, !selectionModel.isSelected(value));
diff --git a/user/src/com/google/gwt/user/cellview/client/AbstractCellTree.java b/user/src/com/google/gwt/user/cellview/client/AbstractCellTree.java
new file mode 100644
index 0000000..649bf0e
--- /dev/null
+++ b/user/src/com/google/gwt/user/cellview/client/AbstractCellTree.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.cellview.client;
+
+import com.google.gwt.event.logical.shared.CloseEvent;
+import com.google.gwt.event.logical.shared.CloseHandler;
+import com.google.gwt.event.logical.shared.HasCloseHandlers;
+import com.google.gwt.event.logical.shared.HasOpenHandlers;
+import com.google.gwt.event.logical.shared.OpenEvent;
+import com.google.gwt.event.logical.shared.OpenHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
+import com.google.gwt.user.client.ui.Composite;
+import com.google.gwt.view.client.TreeViewModel;
+import com.google.gwt.view.client.TreeViewModel.NodeInfo;
+
+/**
+ * An abstract representation of a tree widget that renders items using
+ * {@link com.google.gwt.cell.client.Cell}s.
+ */
+public abstract class AbstractCellTree extends Composite
+    implements HasOpenHandlers<TreeNode>, HasCloseHandlers<TreeNode> {
+
+  /**
+   * The {@link TreeViewModel} that backs the tree.
+   */
+  private final TreeViewModel viewModel;
+
+  /**
+   * Construct a new {@link CellTree} with the specified {@link TreeViewModel}
+   * and root value.
+   *
+   * @param viewModel the {@link TreeViewModel} that backs the tree
+   */
+  public AbstractCellTree(TreeViewModel viewModel) {
+    this.viewModel = viewModel;
+  }
+
+  public HandlerRegistration addCloseHandler(CloseHandler<TreeNode> handler) {
+    return addHandler(handler, CloseEvent.getType());
+  }
+
+  public HandlerRegistration addOpenHandler(OpenHandler<TreeNode> handler) {
+    return addHandler(handler, OpenEvent.getType());
+  }
+
+  /**
+   * Get the root {@link TreeNode}.
+   *
+   * @return the {@link TreeNode} at the root of the tree
+   */
+  public abstract TreeNode getRootTreeNode();
+
+  /**
+   * Get the {@link TreeViewModel} that backs this tree.
+   *
+   * @return the {@link TreeViewModel}
+   */
+  public TreeViewModel getTreeViewModel() {
+    return viewModel;
+  }
+
+  /**
+   * Get the {@link NodeInfo} that will provide the information to retrieve and
+   * display the children of the specified value.
+   *
+   * @param value the value in the parent node
+   * @return the {@link NodeInfo}
+   */
+  protected <T> NodeInfo<?> getNodeInfo(T value) {
+    return viewModel.getNodeInfo(value);
+  }
+
+  /**
+   * Check if the value is known to be a leaf node.
+   *
+   * @param value the value at the node
+   *
+   * @return true if the node is known to be a leaf node, false otherwise
+   */
+  protected boolean isLeaf(Object value) {
+    return viewModel.isLeaf(value);
+  }
+}
diff --git a/user/src/com/google/gwt/user/cellview/client/AbstractHasData.java b/user/src/com/google/gwt/user/cellview/client/AbstractHasData.java
index efd7e5c..13ca6d0 100644
--- a/user/src/com/google/gwt/user/cellview/client/AbstractHasData.java
+++ b/user/src/com/google/gwt/user/cellview/client/AbstractHasData.java
@@ -17,6 +17,8 @@
 
 import com.google.gwt.dom.client.Document;
 import com.google.gwt.dom.client.Element;
+import com.google.gwt.event.logical.shared.ValueChangeEvent;
+import com.google.gwt.event.logical.shared.ValueChangeHandler;
 import com.google.gwt.event.shared.EventHandler;
 import com.google.gwt.event.shared.GwtEvent.Type;
 import com.google.gwt.event.shared.HandlerRegistration;
@@ -85,10 +87,12 @@
 
     public void replaceAllChildren(List<T> values, String html) {
       hasData.replaceAllChildren(values, html);
+      fireValueChangeEvent();
     }
 
     public void replaceChildren(List<T> values, int start, String html) {
       hasData.replaceChildren(values, start, html);
+      fireValueChangeEvent();
     }
 
     public void resetFocus() {
@@ -108,6 +112,18 @@
     public void setSelected(Element elem, boolean selected) {
       hasData.setSelected(elem, selected);
     }
+
+    /**
+     * Fire a value change event.
+     */
+    private void fireValueChangeEvent() {
+      // Use an anonymous class to override ValueChangeEvents's protected
+      // constructor. We can't call ValueChangeEvent.fire() because this class
+      // doesn't implement HasValueChangeHandlers.
+      hasData.fireEvent(
+          new ValueChangeEvent<List<T>>(hasData.getDisplayedItems()) {
+          });
+    }
   }
 
   /**
@@ -379,6 +395,19 @@
       int start, SelectionModel<? super T> selectionModel);
 
   /**
+   * Add a {@link ValueChangeHandler} that is called when the display values
+   * change. Used by {@link CellBrowser} to detect when the displayed data
+   * changes.
+   *
+   * @param handler the handler
+   * @return a {@link HandlerRegistration} to remove the handler
+   */
+  final HandlerRegistration addValueChangeHandler(
+      ValueChangeHandler<List<T>> handler) {
+    return addHandler(handler, ValueChangeEvent.getType());
+  }
+
+  /**
    * Convert the specified HTML into DOM elements and return the parent of the
    * DOM elements.
    *
@@ -410,6 +439,35 @@
   }
 
   /**
+   * Get the first index of a displayed item according to its key.
+   *
+   * @param value the value
+   * @return the index of the item, or -1 of not found
+   */
+  int indexOf(T value) {
+    ProvidesKey<T> keyProvider = getKeyProvider();
+    List<T> items = getDisplayedItems();
+
+    // If no key provider is present, just compare the objets.
+    if (keyProvider == null) {
+      return items.indexOf(value);
+    }
+
+    // Compare the keys of each object.
+    Object key = keyProvider.getKey(value);
+    if (key == null) {
+      return -1;
+    }
+    int itemCount = items.size();
+    for (int i = 0; i < itemCount; i++) {
+      if (key.equals(keyProvider.getKey(items.get(i)))) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  /**
    * Called when selection changes.
    */
   void onUpdateSelection() {
diff --git a/user/src/com/google/gwt/user/cellview/client/CellBrowser.java b/user/src/com/google/gwt/user/cellview/client/CellBrowser.java
index 322dbf7..31d7727 100644
--- a/user/src/com/google/gwt/user/cellview/client/CellBrowser.java
+++ b/user/src/com/google/gwt/user/cellview/client/CellBrowser.java
@@ -26,7 +26,10 @@
 import com.google.gwt.dom.client.Style.Position;
 import com.google.gwt.dom.client.Style.Unit;
 import com.google.gwt.dom.client.Style.Visibility;
-import com.google.gwt.event.shared.GwtEvent;
+import com.google.gwt.event.logical.shared.CloseEvent;
+import com.google.gwt.event.logical.shared.OpenEvent;
+import com.google.gwt.event.logical.shared.ValueChangeEvent;
+import com.google.gwt.event.logical.shared.ValueChangeHandler;
 import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.resources.client.ClientBundle;
 import com.google.gwt.resources.client.CssResource;
@@ -35,7 +38,6 @@
 import com.google.gwt.resources.client.ImageResource.RepeatStyle;
 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.FlowPanel;
 import com.google.gwt.user.client.ui.HasAnimation;
 import com.google.gwt.user.client.ui.ProvidesResize;
@@ -45,9 +47,6 @@
 import com.google.gwt.user.client.ui.Widget;
 import com.google.gwt.view.client.HasData;
 import com.google.gwt.view.client.ProvidesKey;
-import com.google.gwt.view.client.Range;
-import com.google.gwt.view.client.RangeChangeEvent;
-import com.google.gwt.view.client.RowCountChangeEvent;
 import com.google.gwt.view.client.SelectionModel;
 import com.google.gwt.view.client.TreeViewModel;
 import com.google.gwt.view.client.TreeViewModel.NodeInfo;
@@ -61,7 +60,7 @@
  * A "browsable" view of a tree in which only a single node per level may be
  * open at one time.
  */
-public class CellBrowser extends Composite
+public class CellBrowser extends AbstractCellTree
     implements ProvidesResize, RequiresResize, HasAnimation {
 
   /**
@@ -167,6 +166,11 @@
     private Object openKey;
 
     /**
+     * The value of the currently open item.
+     */
+    private C openValue;
+
+    /**
      * The key provider for the node.
      */
     private final ProvidesKey<C> providesKey;
@@ -221,30 +225,13 @@
 
       // Open child nodes.
       if (Event.getTypeInt(event.getType()) == Event.ONMOUSEDOWN) {
-        trimToLevel(level);
-
-        // Remove style from currently open item.
-        Element curOpenItem = Document.get().getElementById(getOpenId());
-        if (curOpenItem != null) {
-          setElementOpenState(curOpenItem.getParentElement(), false);
-        }
-        openKey = null;
-
-        // Save the key of the new open item and update the Element.
-        if (!viewModel.isLeaf(value)) {
-          NodeInfo<?> nodeInfo = viewModel.getNodeInfo(value);
-          if (nodeInfo != null) {
-            openKey = providesKey.getKey(value);
-            setElementOpenState(parent, true);
-            appendTreeNode(nodeInfo);
-          }
-        }
+        setChildState(this, value, true, true);
       }
     }
 
     public void render(C value, Object viewData, StringBuilder sb) {
       boolean isOpen = (openKey == null) ? false : openKey.equals(
-          providesKey.getKey(value));
+          getValueKey(value));
       boolean isSelected = (selectionModel == null)
           ? false : selectionModel.isSelected(value);
       sb.append("<div style='position:relative;padding-right:");
@@ -257,14 +244,10 @@
       if (isSelected) {
         sb.append(" ").append(style.selectedItem());
       }
-      sb.append("'");
-      if (isOpen) {
-        sb.append(" id='").append(getOpenId()).append("'");
-      }
-      sb.append(">");
+      sb.append("'>");
       if (isOpen) {
         sb.append(openImageHtml);
-      } else if (viewModel.isLeaf(value)) {
+      } else if (isLeaf(value)) {
         sb.append(LEAF_IMAGE);
       } else {
         sb.append(closedImageHtml);
@@ -289,49 +272,13 @@
     }
 
     /**
-     * Get the image element of the decorated cell.
+     * Get the key for the specified value.
      *
-     * @param parent the parent of this cell
-     * @return the image element
+     * @param value the value
+     * @return the key
      */
-    private Element getImageElement(Element parent) {
-      return parent.getFirstChildElement().getFirstChildElement();
-    }
-
-    /**
-     * Get the ID of the open element.
-     *
-     * @return the ID
-     */
-    private String getOpenId() {
-      return uniqueId + "-" + level;
-    }
-
-    /**
-     * Replace the image element of a cell and update the styles associated with
-     * the open state.
-     *
-     * @param parent the parent element of the cell
-     * @param open true if open, false if closed
-     */
-    private void setElementOpenState(Element parent, boolean open) {
-      // Update the style name and ID.
-      Element wrapper = parent.getFirstChildElement();
-      if (open) {
-        wrapper.addClassName(style.openItem());
-        wrapper.setId(getOpenId());
-      } else {
-        wrapper.removeClassName(style.openItem());
-        wrapper.setId("");
-      }
-
-      // Replace the image element.
-      String html = open ? openImageHtml : closedImageHtml;
-      Element tmp = Document.get().createDivElement();
-      tmp.setInnerHTML(html);
-      Element imageElem = tmp.getFirstChildElement();
-      Element oldImg = getImageElement(parent);
-      wrapper.replaceChild(imageElem, oldImg);
+    private Object getValueKey(C value) {
+      return (providesKey == null) ? value : providesKey.getKey(value);
     }
   }
 
@@ -381,43 +328,146 @@
    *
    * @param <C> the data type of the children of the node
    */
-  private class TreeNode<C> {
-    private CellDecorator<C> cell;
-    private HasData<C> view;
+  private class TreeNodeImpl<C> implements TreeNode {
+    private final CellDecorator<C> cell;
+    private final AbstractHasData<C> display;
     private NodeInfo<C> nodeInfo;
-    private Widget widget;
+    private final Object value;
+    private final HandlerRegistration valueChangeHandler;
+    private final Widget widget;
 
     /**
-     * Construct a new {@link TreeNode}.
+     * Construct a new {@link TreeNodeImpl}.
      *
      * @param nodeInfo the nodeInfo for the children nodes
-     * @param view the view associated with the node
+     * @param value the value of the node
+     * @param display the display associated with the node
+     * @param cell the {@link Cell} used to render the data
      * @param widget the widget that represents the list view
      */
-    public TreeNode(NodeInfo<C> nodeInfo, HasData<C> view,
-        CellDecorator<C> cell, Widget widget) {
+    public TreeNodeImpl(final NodeInfo<C> nodeInfo, Object value,
+        AbstractHasData<C> display, final CellDecorator<C> cell,
+        Widget widget) {
       this.cell = cell;
-      this.view = view;
+      this.display = display;
       this.nodeInfo = nodeInfo;
+      this.value = value;
       this.widget = widget;
+
+      // Trim to the current level if the open node disappears.
+      valueChangeHandler = display.addValueChangeHandler(
+          new ValueChangeHandler<List<C>>() {
+            public void onValueChange(ValueChangeEvent<List<C>> event) {
+              Object openKey = cell.openKey;
+              if (openKey != null) {
+                boolean stillExists = false;
+                List<C> displayValues = event.getValue();
+                for (C displayValue : displayValues) {
+                  if (openKey.equals(cell.getValueKey(displayValue))) {
+                    stillExists = true;
+                    break;
+                  }
+                }
+                if (!stillExists) {
+                  trimToLevel(cell.level);
+                }
+              }
+            }
+          });
+    }
+
+    public int getChildCount() {
+      assertNotDestroyed();
+      return display.getChildCount();
+    }
+
+    public C getChildValue(int index) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return display.getDisplayedItem(index);
+    }
+
+    public int getIndex() {
+      assertNotDestroyed();
+      TreeNodeImpl<?> parent = getParent();
+      return (parent == null) ? 0 : parent.getOpenIndex();
+    }
+
+    public TreeNodeImpl<?> getParent() {
+      assertNotDestroyed();
+      return (cell.level == 0) ? null : treeNodes.get(cell.level - 1);
+    }
+
+    public Object getValue() {
+      return value;
+    }
+
+    public boolean isChildLeaf(int index) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return isLeaf(getChildValue(index));
+    }
+
+    public boolean isChildOpen(int index) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return (cell.openKey == null) ? false : cell.openKey.equals(
+          cell.getValueKey(getChildValue(index)));
+    }
+
+    public boolean isDestroyed() {
+      return nodeInfo == null;
+    }
+
+    public TreeNode setChildOpen(int index, boolean open) {
+      return setChildOpen(index, open, true);
+    }
+
+    public TreeNode setChildOpen(int index, boolean open, boolean fireEvents) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return setChildState(cell, getChildValue(index), open, fireEvents);
     }
 
     /**
-     * Get the {@link CellDecorator} used to render the node.
-     *
-     * @return the cell decorator
+     * Assert that the node has not been destroyed.
      */
-    public CellDecorator<C> getCell() {
-      return cell;
+    private void assertNotDestroyed() {
+      if (isDestroyed()) {
+        throw new IllegalStateException("TreeNode no longer exists.");
+      }
+    }
+
+    /**
+     * Check the child bounds.
+     *
+     * @param index the index of the child
+     * @throws IndexOutOfBoundsException if the child is not in range
+     */
+    private void checkChildBounds(int index) {
+      if ((index < 0) || (index >= getChildCount())) {
+        throw new IndexOutOfBoundsException();
+      }
     }
 
     /**
      * Unregister the list view and remove it from the widget.
      */
-    void cleanup() {
-      view.setSelectionModel(null);
+    private void destroy() {
+      valueChangeHandler.removeHandler();
+      display.setSelectionModel(null);
       nodeInfo.unsetDataDisplay();
       getSplitLayoutPanel().remove(widget);
+      nodeInfo = null;
+    }
+
+    /**
+     * Get the index of the open item.
+     *
+     * @return the index of the open item, or -1 if not found
+     */
+    private int getOpenIndex() {
+      return display.indexOf(cell.openValue);
     }
   }
 
@@ -467,11 +517,6 @@
   private final String closedImageHtml;
 
   /**
-   * The unique ID assigned to this tree widget.
-   */
-  private final String uniqueId = Document.get().createUniqueId();
-
-  /**
    * A boolean indicating whether or not animations are enabled.
    */
   private boolean isAnimationEnabled;
@@ -502,14 +547,10 @@
   private Element scrollLock;
 
   /**
-   * The visible {@link TreeNode}.
+   * The visible {@link TreeNodeImpl}s.
    */
-  private final List<TreeNode<?>> treeNodes = new ArrayList<TreeNode<?>>();
-
-  /**
-   * The {@link TreeViewModel} that backs the tree.
-   */
-  private final TreeViewModel viewModel;
+  private final List<TreeNodeImpl<?>> treeNodes = new ArrayList<
+      TreeNodeImpl<?>>();
 
   /**
    * Construct a new {@link CellBrowser}.
@@ -532,7 +573,7 @@
    */
   public <T> CellBrowser(
       TreeViewModel viewModel, T rootValue, Resources resources) {
-    this.viewModel = viewModel;
+    super(viewModel);
     this.style = resources.cellBrowserStyle();
     this.style.ensureInjected();
     initWidget(new SplitLayoutPanel());
@@ -560,7 +601,7 @@
     getElement().appendChild(scrollLock);
 
     // Associate the first view with the rootValue.
-    appendTreeNode(viewModel.getNodeInfo(rootValue));
+    appendTreeNode(getNodeInfo(rootValue), rootValue);
 
     // Catch scroll events.
     sinkEvents(Event.ONSCROLL);
@@ -584,6 +625,11 @@
     return minWidth;
   }
 
+  @Override
+  public TreeNode getRootTreeNode() {
+    return treeNodes.get(0);
+  }
+
   public boolean isAnimationEnabled() {
     return isAnimationEnabled;
   }
@@ -634,8 +680,9 @@
    * @param cell the cell to use in the list view
    * @return the {@link HasData}
    */
-  // TODO(jlabanca): Move createView into constructor factory arg?
-  protected <C> HasData<C> createDisplay(NodeInfo<C> nodeInfo, Cell<C> cell) {
+  // TODO(jlabanca): Move createDisplay into constructor factory arg?
+  protected <C> AbstractHasData<C> createDisplay(
+      NodeInfo<C> nodeInfo, Cell<C> cell) {
     CellList<C> display = new CellList<C>(cell, getCellListResources());
     display.setValueUpdater(nodeInfo.getValueUpdater());
     display.setKeyProvider(nodeInfo.getProvidesKey());
@@ -671,123 +718,43 @@
   }
 
   /**
-   * Create a new {@link TreeNode} and append it to the end of the LayoutPanel.
+   * Create a new {@link TreeNodeImpl} and append it to the end of the
+   * LayoutPanel.
    *
    * @param <C> the data type of the children
    * @param nodeInfo the info about the node
+   * @param value the value of the open node
    */
-  private <C> void appendTreeNode(final NodeInfo<C> nodeInfo) {
+  private <C> void appendTreeNode(final NodeInfo<C> nodeInfo, Object value) {
     // Create the list view.
     final int level = treeNodes.size();
     final CellDecorator<C> cell = new CellDecorator<C>(nodeInfo, level);
-    final HasData<C> view = createDisplay(nodeInfo, cell);
-    assert (view instanceof Widget) : "createView() must return a widget";
+    final AbstractHasData<C> view = createDisplay(nodeInfo, cell);
 
     // Create a pager and wrap the components in a scrollable container.
     ScrollPanel scrollable = new ScrollPanel();
     final Widget pager = createPager(view);
     if (pager != null) {
       FlowPanel flowPanel = new FlowPanel();
-      flowPanel.add((Widget) view);
+      flowPanel.add(view);
       flowPanel.add(pager);
       scrollable.setWidget(flowPanel);
     } else {
-      scrollable.setWidget((Widget) view);
+      scrollable.setWidget(view);
     }
     scrollable.setStyleName(style.column());
     if (level == 0) {
       scrollable.addStyleName(style.firstColumn());
     }
 
-    // Create a delegate list view so we can trap data changes.
-    HasData<C> viewDelegate = new HasData<C>() {
-
-      public HandlerRegistration addRangeChangeHandler(
-          RangeChangeEvent.Handler handler) {
-        return view.addRangeChangeHandler(handler);
-      }
-
-      public HandlerRegistration addRowCountChangeHandler(
-          RowCountChangeEvent.Handler handler) {
-        return view.addRowCountChangeHandler(handler);
-      }
-
-      public void fireEvent(GwtEvent<?> event) {
-        view.fireEvent(event);
-      }
-
-      public int getRowCount() {
-        return view.getRowCount();
-      }
-
-      public SelectionModel<? super C> getSelectionModel() {
-        return view.getSelectionModel();
-      }
-
-      public Range getVisibleRange() {
-        return view.getVisibleRange();
-      }
-
-      public boolean isRowCountExact() {
-        return view.isRowCountExact();
-      }
-
-      public final void setRowCount(int count) {
-        view.setRowCount(count);
-      }
-
-      public void setRowCount(int count, boolean isExact) {
-        view.setRowCount(count, isExact);
-      }
-
-      public void setRowData(int start, List<C> values) {
-        // Trim to the current level if the open node no longer exists.
-        TreeNode<?> node = treeNodes.get(level);
-        Object openKey = node.getCell().openKey;
-        if (openKey != null) {
-          boolean stillExists = false;
-          ProvidesKey<C> keyProvider = nodeInfo.getProvidesKey();
-          for (C value : values) {
-            if (openKey.equals(keyProvider.getKey(value))) {
-              stillExists = true;
-              break;
-            }
-          }
-          if (!stillExists) {
-            trimToLevel(level);
-          }
-        }
-
-        // Refresh the list.
-        view.setRowData(start, values);
-      }
-
-      public void setSelectionModel(SelectionModel<? super C> selectionModel) {
-        view.setSelectionModel(selectionModel);
-      }
-
-      public void setVisibleRange(int start, int length) {
-        view.setVisibleRange(start, length);
-      }
-
-      public void setVisibleRange(Range range) {
-        view.setVisibleRange(range);
-      }
-
-      public void setVisibleRangeAndClearData(
-          Range range, boolean forceRangeChangeEvent) {
-        view.setVisibleRangeAndClearData(range, forceRangeChangeEvent);
-      }
-    };
-
     // Create a TreeNode.
-    TreeNode<C> treeNode = new TreeNode<C>(
-        nodeInfo, viewDelegate, cell, scrollable);
+    TreeNodeImpl<C> treeNode = new TreeNodeImpl<C>(
+        nodeInfo, value, view, cell, scrollable);
     treeNodes.add(treeNode);
 
     // Attach the view to the selection model and node info.
     view.setSelectionModel(nodeInfo.getSelectionModel());
-    nodeInfo.setDataDisplay(viewDelegate);
+    nodeInfo.setDataDisplay(view);
 
     // Add the view to the LayoutPanel.
     SplitLayoutPanel splitPanel = getSplitLayoutPanel();
@@ -830,6 +797,83 @@
   }
 
   /**
+   * Set the open state of a tree node.
+   *
+   * @param cell the Cell that changed state.
+   * @param value the value to open
+   * @param open true to open, false to close
+   * @param fireEvents true to fireEvents
+   * @return the open {@link TreeNode}, or null if not opened
+   */
+  private <C> TreeNode setChildState(
+      CellDecorator<C> cell, C value, boolean open, boolean fireEvents) {
+
+    // Early exit if the node is a leaf.
+    if (isLeaf(value)) {
+      return null;
+    }
+
+    // Get the key of the value to open.
+    Object newKey = cell.getValueKey(value);
+
+    if (open) {
+      if (newKey == null) {
+        // Early exit if opening but the specified node has no key.
+        return null;
+      } else if (newKey.equals(cell.openKey)) {
+        // Early exit if opening but the specified node is already open.
+        return treeNodes.get(cell.level + 1);
+      }
+
+      // Close the currently open node.
+      if (cell.openKey != null) {
+        setChildState(cell, cell.openValue, false, fireEvents);
+      }
+
+      // Get the child node info.
+      NodeInfo<?> childNodeInfo = getNodeInfo(value);
+      if (childNodeInfo == null) {
+        return null;
+      }
+
+      // Update the cell so it renders the styles correctly.
+      cell.openValue = value;
+      cell.openKey = cell.getValueKey(value);
+
+      // Refresh the display to update the styles for this node.
+      treeNodes.get(cell.level).display.redraw();
+
+      // Add the child node.
+      appendTreeNode(childNodeInfo, value);
+
+      if (fireEvents) {
+        OpenEvent.fire(this, treeNodes.get(cell.level + 1));
+      }
+      return treeNodes.get(cell.level + 1);
+    } else {
+      // Early exit if closing and the specified node or all nodes are closed.
+      if (cell.openKey == null || !cell.openKey.equals(newKey)) {
+        return null;
+      }
+
+      // Close the node.
+      TreeNode closedNode = treeNodes.get(cell.level + 1);
+      trimToLevel(cell.level);
+      cell.openKey = null;
+      cell.openValue = null;
+
+      // Refresh the display to update the styles for this node.
+      treeNodes.get(cell.level).display.redraw();
+
+      if (fireEvents) {
+        CloseEvent.fire(this, closedNode);
+      }
+    }
+
+    return null;
+  }
+
+  /**
    * Reduce the number of {@link HasData}s down to the specified level.
    *
    * @param level the level to trim to
@@ -841,8 +885,8 @@
     // Remove the views that are no longer needed.
     int curLevel = treeNodes.size() - 1;
     while (curLevel > level) {
-      TreeNode<?> removed = treeNodes.remove(curLevel);
-      removed.cleanup();
+      TreeNodeImpl<?> removed = treeNodes.remove(curLevel);
+      removed.destroy();
       curLevel--;
     }
   }
diff --git a/user/src/com/google/gwt/user/cellview/client/CellTree.java b/user/src/com/google/gwt/user/cellview/client/CellTree.java
index 0ae1b54..1764aa2 100644
--- a/user/src/com/google/gwt/user/cellview/client/CellTree.java
+++ b/user/src/com/google/gwt/user/cellview/client/CellTree.java
@@ -28,7 +28,6 @@
 import com.google.gwt.resources.client.ImageResource.ImageOptions;
 import com.google.gwt.resources.client.ImageResource.RepeatStyle;
 import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.HasAnimation;
 import com.google.gwt.user.client.ui.SimplePanel;
 import com.google.gwt.view.client.TreeViewModel;
@@ -38,7 +37,7 @@
 /**
  * A view of a tree.
  */
-public class CellTree extends Composite implements HasAnimation {
+public class CellTree extends AbstractCellTree implements HasAnimation {
 
   /**
    * A cleaner version of the table that uses less graphics.
@@ -452,11 +451,6 @@
   private final Style style;
 
   /**
-   * The {@link TreeViewModel} that backs the tree.
-   */
-  private final TreeViewModel viewModel;
-
-  /**
    * Construct a new {@link CellTree}.
    *
    * @param <T> the type of data in the root node
@@ -475,9 +469,9 @@
    * @param rootValue the hidden root value of the tree
    * @param resources the resources used to render the tree
    */
-  public <T> CellTree(TreeViewModel viewModel, T rootValue,
-      Resources resources) {
-    this.viewModel = viewModel;
+  public <T> CellTree(
+      TreeViewModel viewModel, T rootValue, Resources resources) {
+    super(viewModel);
     this.style = resources.cellTreeStyle();
     this.style.ensureInjected();
     initWidget(new SimplePanel());
@@ -502,10 +496,10 @@
     sinkEvents(Event.ONCLICK | Event.ONKEYDOWN | Event.ONKEYUP);
 
     // Associate a view with the item.
-    CellTreeNodeView<T> root = new CellTreeNodeView<T>(this, null, null,
-        getElement(), rootValue);
+    CellTreeNodeView<T> root = new CellTreeNodeView<T>(
+        this, null, null, getElement(), rootValue);
     keyboardSelectedNode = rootNode = root;
-    root.setOpen(true);
+    root.setOpen(true, false);
     keyboardSelectedNode.keyboardEnter(0, false);
   }
 
@@ -529,8 +523,9 @@
     return defaultNodeSize;
   }
 
-  public TreeViewModel getTreeViewModel() {
-    return viewModel;
+  @Override
+  public TreeNode getRootTreeNode() {
+    return rootNode.getTreeNode();
   }
 
   public boolean isAnimationEnabled() {
@@ -577,7 +572,7 @@
         // Open the node when the open image is clicked.
         Element showMoreElem = nodeView.getShowMoreElement();
         if (nodeView.getImageElement().isOrHasChild(target)) {
-          nodeView.setOpen(!nodeView.isOpen());
+          nodeView.setOpen(!nodeView.isOpen(), true);
           return;
         } else if (showMoreElem != null && showMoreElem.isOrHasChild(target)) {
           nodeView.showMore();
@@ -631,6 +626,13 @@
   }
 
   /**
+   * Cancel a pending animation.
+   */
+  void cancelTreeNodeAnimation() {
+    animation.cancel();
+  }
+
+  /**
    * Get the HTML to render the closed image.
    *
    * @param isTop true if the top element, false if not
@@ -680,16 +682,16 @@
    */
   void maybeAnimateTreeNode(CellTreeNodeView<?> node) {
     if (animation != null) {
-      animation.animate(node, node.consumeAnimate() && isAnimationEnabled()
-          && !node.isRootNode());
+      animation.animate(node,
+          node.consumeAnimate() && isAnimationEnabled() && !node.isRootNode());
     }
   }
 
   /**
    * Collects parents going up the element tree, terminated at the tree root.
    */
-  private void collectElementChain(ArrayList<Element> chain, Element hRoot,
-      Element hElem) {
+  private void collectElementChain(
+      ArrayList<Element> chain, Element hRoot, Element hElem) {
     if ((hElem == null) || (hElem == hRoot)) {
       return;
     }
@@ -698,8 +700,8 @@
     chain.add(hElem);
   }
 
-  private CellTreeNodeView<?> findItemByChain(ArrayList<Element> chain,
-      int idx, CellTreeNodeView<?> parent) {
+  private CellTreeNodeView<?> findItemByChain(
+      ArrayList<Element> chain, int idx, CellTreeNodeView<?> parent) {
     if (idx == chain.size()) {
       return parent;
     }
@@ -815,7 +817,7 @@
         // TODO(rice) - try different key bahavior mappings such as
         // left=close, right=open, enter=toggle.
         if (child != null && !child.isLeaf()) {
-          child.setOpen(!child.isOpen());
+          child.setOpen(!child.isOpen(), true);
           return true;
         }
         break;
diff --git a/user/src/com/google/gwt/user/cellview/client/CellTreeNodeView.java b/user/src/com/google/gwt/user/cellview/client/CellTreeNodeView.java
index ce91186..dc0fc1f 100644
--- a/user/src/com/google/gwt/user/cellview/client/CellTreeNodeView.java
+++ b/user/src/com/google/gwt/user/cellview/client/CellTreeNodeView.java
@@ -23,6 +23,8 @@
 import com.google.gwt.dom.client.Style.Display;
 import com.google.gwt.dom.client.Style.Overflow;
 import com.google.gwt.dom.client.Style.Position;
+import com.google.gwt.event.logical.shared.CloseEvent;
+import com.google.gwt.event.logical.shared.OpenEvent;
 import com.google.gwt.event.shared.EventHandler;
 import com.google.gwt.event.shared.GwtEvent;
 import com.google.gwt.event.shared.GwtEvent.Type;
@@ -55,7 +57,10 @@
 class CellTreeNodeView<T> extends UIObject {
 
   /**
-   * The {@link com.google.gwt.view.client.HasData} used to show children.
+   * The {@link com.google.gwt.view.client.HasData} used to show children. This
+   * class is intentionally static because we might move it to a new
+   * {@link CellTreeNodeView}, and we don't want non-static references to the
+   * old {@link CellTreeNodeView}.
    *
    * @param <C> the child item type
    */
@@ -72,8 +77,8 @@
         this.childContainer = childContainer;
       }
 
-      public <H extends EventHandler> HandlerRegistration addHandler(H handler,
-          Type<H> type) {
+      public <H extends EventHandler> HandlerRegistration addHandler(
+          H handler, Type<H> type) {
         return handlerManger.addHandler(type, handler);
       }
 
@@ -86,8 +91,8 @@
       }
 
       public ElementIterator getChildIterator() {
-        return new HasDataPresenter.DefaultElementIterator(this,
-            childContainer.getFirstChildElement());
+        return new HasDataPresenter.DefaultElementIterator(
+            this, childContainer.getFirstChildElement());
       }
 
       public void onUpdateSelection() {
@@ -181,6 +186,16 @@
         // Replace the child nodes.
         Map<Object, CellTreeNodeView<?>> savedViews = saveChildState(values, 0);
         AbstractHasData.replaceAllChildren(nodeView.tree, childContainer, html);
+
+        // Trim the list of children.
+        int size = values.size();
+        int childCount = nodeView.children.size();
+        while (childCount > size) {
+          childCount--;
+          nodeView.children.remove(childCount);
+        }
+
+        // Reattach the open nodes.
         loadChildState(values, 0, savedViews);
 
         // Animate the child container open.
@@ -192,18 +207,18 @@
       public void replaceChildren(List<C> values, int start, String html) {
         Map<Object, CellTreeNodeView<?>> savedViews = saveChildState(values, 0);
 
-        Element newChildren = AbstractHasData.convertToElements(nodeView.tree,
-            getTmpElem(), html);
-        AbstractHasData.replaceChildren(nodeView.tree, childContainer,
-            newChildren, start, html);
+        Element newChildren = AbstractHasData.convertToElements(
+            nodeView.tree, getTmpElem(), html);
+        AbstractHasData.replaceChildren(
+            nodeView.tree, childContainer, newChildren, start, html);
 
         loadChildState(values, 0, savedViews);
       }
 
       public void resetFocus() {
         if (nodeView.keyboardSelectedIndex != -1) {
-          nodeView.keyboardEnter(nodeView.keyboardSelectedIndex,
-              nodeView.keyboardFocused);
+          nodeView.keyboardEnter(
+              nodeView.keyboardSelectedIndex, nodeView.keyboardFocused);
         }
       }
 
@@ -230,14 +245,15 @@
         int end = start + len;
         int childCount = nodeView.getChildCount();
         ProvidesKey<C> providesKey = nodeInfo.getProvidesKey();
-        Element childElem =
-          nodeView.ensureChildContainer().getFirstChildElement();
+
+        Element container = nodeView.ensureChildContainer();
+        Element childElem = container.getFirstChildElement();
         for (int i = start; i < end; i++) {
           C childValue = values.get(i - start);
-          CellTreeNodeView<C> child = nodeView.createTreeNodeView(nodeInfo,
-              childElem, childValue, null);
-          CellTreeNodeView<?> savedChild =
-            savedViews.remove(providesKey.getKey(childValue));
+          CellTreeNodeView<C> child = nodeView.createTreeNodeView(
+              nodeInfo, childElem, childValue, null);
+          CellTreeNodeView<?> savedChild = savedViews.remove(
+              providesKey.getKey(childValue));
           // Copy the saved child's state into the new child
           if (savedChild != null) {
             child.animationFrame = savedChild.animationFrame;
@@ -250,20 +266,25 @@
             child.open = savedChild.open;
             child.showMoreElem = savedChild.showMoreElem;
 
+            // Transfer the tree node so that if the user has a handle to it, it
+            // won't be destroyed.
+            child.treeNode = savedChild.treeNode;
+            if (child.treeNode != null) {
+              child.treeNode.nodeView = child;
+            }
+
             // Swap the node view in the child. We reuse the same NodeListView
             // so that we don't have to unset and register a new view with the
-            // NodeInfo.
-            savedChild.listView.setNodeView(child);
+            // NodeInfo, which would inevitably cause the NodeInfo to push
+            // new data.
+            child.listView = savedChild.listView;
+            child.listView.nodeView = child;
 
             // Copy the child container element to the new child
             child.getElement().appendChild(savedChild.ensureAnimationFrame());
           }
 
           if (childCount > i) {
-            if (savedChild == null) {
-              // Cleanup the child node if we aren't going to reuse it.
-              nodeView.children.get(i).cleanup();
-            }
             nodeView.children.set(i, child);
           } else {
             nodeView.children.add(child);
@@ -281,8 +302,8 @@
        * @param start the start index
        * @return the map of open nodes
        */
-      private Map<Object, CellTreeNodeView<?>> saveChildState(List<C> values,
-          int start) {
+      private Map<Object, CellTreeNodeView<?>> saveChildState(
+          List<C> values, int start) {
         // Ensure that we have a children array.
         if (nodeView.children == null) {
           nodeView.children = new ArrayList<CellTreeNodeView<?>>();
@@ -292,20 +313,23 @@
         int len = values.size();
         int end = start + len;
         int childCount = nodeView.getChildCount();
-        Map<Object, CellTreeNodeView<?>> openNodes =
-          new HashMap<Object, CellTreeNodeView<?>>();
+        Map<Object, CellTreeNodeView<?>> openNodes = new HashMap<
+            Object, CellTreeNodeView<?>>();
         for (int i = start; i < end && i < childCount; i++) {
           CellTreeNodeView<?> child = nodeView.getChildNode(i);
-          // Ignore child nodes that are closed.
           if (child.isOpen()) {
+            // Save child nodes that are open.
             openNodes.put(child.getValueKey(), child);
+          } else {
+            // Cleanup child nodes that are closed.
+            child.cleanup(true);
           }
         }
 
         // Trim the saved views down to the children that still exists.
         ProvidesKey<C> providesKey = nodeInfo.getProvidesKey();
-        Map<Object, CellTreeNodeView<?>> savedViews =
-          new HashMap<Object, CellTreeNodeView<?>>();
+        Map<Object, CellTreeNodeView<?>> savedViews = new HashMap<
+            Object, CellTreeNodeView<?>>();
         for (C childValue : values) {
           // Remove any child elements that correspond to prior children
           // so the call to setInnerHtml will not destroy them
@@ -316,6 +340,12 @@
             savedViews.put(key, savedView);
           }
         }
+
+        // Cleanup the remaining open nodes that are not in the new data set.
+        for (CellTreeNodeView<?> lostNode : openNodes.values()) {
+          lostNode.cleanup(true);
+        }
+
         return savedViews;
       }
     }
@@ -335,8 +365,8 @@
       this.nodeView = nodeView;
       cell = nodeInfo.getCell();
 
-      presenter = new HasDataPresenter<C>(this, new View(
-          nodeView.ensureChildContainer()), pageSize);
+      presenter = new HasDataPresenter<C>(
+          this, new View(nodeView.ensureChildContainer()), pageSize);
 
       // Use a pager to update buttons.
       presenter.addRowCountChangeHandler(new RowCountChangeEvent.Handler() {
@@ -419,23 +449,102 @@
         Range range, boolean forceRangeChangeEvent) {
       presenter.setVisibleRangeAndClearData(range, forceRangeChangeEvent);
     }
+  }
+
+  /**
+   * An implementation of {@link TreeNode} that delegates to a
+   * {@link CellTreeNodeView}. This class is intentionally static because we
+   * might move it to a new {@link CellTreeNodeView}, and we don't want
+   * non-static references to the old {@link CellTreeNodeView}.
+   */
+  private static class TreeNodeImpl implements TreeNode {
+
+    private CellTreeNodeView<?> nodeView;
+
+    public TreeNodeImpl(CellTreeNodeView<?> nodeView) {
+      this.nodeView = nodeView;
+    }
+
+    public int getChildCount() {
+      assertNotDestroyed();
+      return nodeView.getChildCount();
+    }
+
+    public Object getChildValue(int index) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return nodeView.getChildNode(index).value;
+    }
+
+    public int getIndex() {
+      assertNotDestroyed();
+      return (nodeView.parentNode == null)
+          ? 0 : nodeView.parentNode.children.indexOf(nodeView);
+    }
+
+    public TreeNode getParent() {
+      assertNotDestroyed();
+      return nodeView.isRootNode() ? null : nodeView.parentNode.treeNode;
+    }
+
+    public Object getValue() {
+      return nodeView.value;
+    }
+
+    public boolean isChildLeaf(int index) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return nodeView.getChildNode(index).isLeaf();
+    }
+
+    public boolean isChildOpen(int index) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      return nodeView.getChildNode(index).isOpen();
+    }
+
+    public boolean isDestroyed() {
+      return nodeView.isDestroyed || !nodeView.isOpen();
+    }
+
+    public TreeNode setChildOpen(int index, boolean open) {
+      return setChildOpen(index, open, true);
+    }
+
+    public TreeNode setChildOpen(int index, boolean open, boolean fireEvents) {
+      assertNotDestroyed();
+      checkChildBounds(index);
+      CellTreeNodeView<?> child = nodeView.getChildNode(index);
+      return child.setOpen(open, fireEvents) ? child.treeNode : null;
+    }
 
     /**
-     * Assign this {@link HasData} to a new {@link CellTreeNodeView}.
-     *
-     * @param nodeView the new node view
+     * Assert that the node has not been destroyed.
      */
-    private void setNodeView(CellTreeNodeView<?> nodeView) {
-      this.nodeView.listView = null;
-      this.nodeView = nodeView;
-      nodeView.listView = this;
+    private void assertNotDestroyed() {
+      if (isDestroyed()) {
+        throw new IllegalStateException("TreeNode no longer exists.");
+      }
+    }
+
+    /**
+     * Check the child bounds.
+     *
+     * @param index the index of the child
+     * @throws IndexOutOfBoundsException if the child is not in range
+     */
+    private void checkChildBounds(int index) {
+      if ((index < 0) || (index >= getChildCount())) {
+        throw new IndexOutOfBoundsException();
+      }
     }
   }
 
   /**
    * The element used in place of an image when a node has no children.
    */
-  private static final String LEAF_IMAGE = "<div style='position:absolute;display:none;'></div>";
+  private static final String LEAF_IMAGE =
+      "<div style='position:absolute;display:none;'></div>";
 
   /**
    * The temporary element used to render child items.
@@ -449,7 +558,8 @@
    * @return the cell parent within the node
    */
   private static Element getCellParent(Element nodeElem) {
-    return getSelectionElement(nodeElem).getFirstChildElement().getChild(1).cast();
+    return getSelectionElement(nodeElem).getFirstChildElement().getChild(
+        1).cast();
   }
 
   /**
@@ -535,6 +645,11 @@
   private Element emptyMessageElem;
 
   /**
+   * Set to true when the node is destroyed.
+   */
+  private boolean isDestroyed;
+
+  /**
    * True if the keyboard selection has focus.
    */
   private boolean keyboardFocused;
@@ -590,6 +705,13 @@
   private final CellTree tree;
 
   /**
+   * The publicly visible tree node. The {@link CellTreeNodeView} doesn't
+   * implement {@link TreeNode} directly because we want to transfer the user's
+   * handle to the {@link TreeNode} to the new {@link CellTreeNodeView}.
+   */
+  private TreeNodeImpl treeNode;
+
+  /**
    * This node's value.
    */
   private T value;
@@ -622,7 +744,7 @@
   }
 
   public boolean isLeaf() {
-    return tree.getTreeViewModel().isLeaf(value);
+    return tree.isLeaf(value);
   }
 
   /**
@@ -638,19 +760,31 @@
    * Sets whether this item's children are displayed.
    *
    * @param open whether the item is open
+   * @param fireEvents true to fire events if the state changes
+   * @return true if successfully opened, false otherwise.
    */
-  public void setOpen(boolean open) {
+  public boolean setOpen(boolean open, boolean fireEvents) {
     // Early out.
     if (this.open == open) {
-      return;
+      return this.open;
     }
 
+    // If this node is a leaf node, do not call TreeViewModel.getNodeInfo().
+    if (open && isLeaf()) {
+      return false;
+    }
+
+    // The animation clears the innerHtml of the childContainer. If we reopen a
+    // node as its closing, it is possible that the new data will be set
+    // synchronously, so we have to cancel the animation before attaching the
+    // data display to the node info.
+    tree.cancelTreeNodeAnimation();
     this.animate = true;
     this.open = open;
     if (open) {
       if (!nodeInfoLoaded) {
         nodeInfoLoaded = true;
-        nodeInfo = tree.getTreeViewModel().getNodeInfo(value);
+        nodeInfo = tree.getNodeInfo(value);
 
         // Sink events for the new node.
         if (nodeInfo != null) {
@@ -678,22 +812,39 @@
         }
         ensureAnimationFrame().getStyle().setProperty("display", "");
         onOpen(nodeInfo);
+
+        // Fire an event.
+        if (fireEvents) {
+          OpenEvent.fire(tree, getTreeNode());
+        }
+      } else {
+        this.open = false;
       }
     } else {
       if (!isRootNode()) {
         setStyleName(getCellParent(), tree.getStyle().openItem(), false);
       }
-      cleanup();
+      cleanup(false);
       tree.maybeAnimateTreeNode(this);
       updateImage(false);
       keyboardExit();
+      keyboardSelectedIndex = -1;
+
+      // Fire an event.
+      if (fireEvents) {
+        CloseEvent.fire(tree, getTreeNode());
+      }
     }
+
+    return this.open;
   }
 
   /**
    * Unregister the list handler and destroy all child nodes.
+   *
+   * @param destroy true to destroy this node
    */
-  protected void cleanup() {
+  protected void cleanup(boolean destroy) {
     // Unregister the list handler.
     if (listView != null) {
       listView.cleanup();
@@ -701,13 +852,18 @@
       listView = null;
     }
 
-    // Recursively kill children.
+    // Recursively destroy children.
     if (children != null) {
       for (CellTreeNodeView<?> child : children) {
-        child.cleanup();
+        child.cleanup(true);
       }
       children = null;
     }
+
+    // Destroy this node.
+    if (destroy) {
+      isDestroyed = true;
+    }
   }
 
   protected boolean consumeAnimate() {
@@ -727,8 +883,8 @@
    * @param viewData view data associated with the node
    * @return a TreeNodeView of suitable type
    */
-  protected <C> CellTreeNodeView<C> createTreeNodeView(NodeInfo<C> nodeInfo,
-      Element childElem, C childValue, Object viewData) {
+  protected <C> CellTreeNodeView<C> createTreeNodeView(
+      NodeInfo<C> nodeInfo, Element childElem, C childValue, Object viewData) {
     return new CellTreeNodeView<C>(tree, this, nodeInfo, childElem, childValue);
   }
 
@@ -741,8 +897,7 @@
     if (parentNodeInfo != null) {
       Cell<T> parentCell = parentNodeInfo.getCell();
       String eventType = event.getType();
-      SelectionModel<? super T> selectionModel =
-        parentNodeInfo.getSelectionModel();
+          SelectionModel<? super T> selectionModel = parentNodeInfo.getSelectionModel();
 
       // Update selection.
       if (selectionModel != null && "click".equals(eventType)
@@ -756,8 +911,8 @@
       Object key = getValueKey();
       Set<String> consumedEvents = parentCell.getConsumedEvents();
       if (consumedEvents != null && consumedEvents.contains(eventType)) {
-        parentCell.onBrowserEvent(cellParent, value, key, event,
-            parentNodeInfo.getValueUpdater());
+        parentCell.onBrowserEvent(
+            cellParent, value, key, event, parentNodeInfo.getValueUpdater());
       }
     }
   }
@@ -794,8 +949,8 @@
    * @param <C> the child data type of the node
    */
   protected <C> void onOpen(final NodeInfo<C> nodeInfo) {
-    NodeCellList<C> view = new NodeCellList<C>(nodeInfo, this,
-        tree.getDefaultNodeSize());
+    NodeCellList<C> view = new NodeCellList<C>(
+        nodeInfo, this, tree.getDefaultNodeSize());
     listView = view;
     view.setSelectionModel(nodeInfo.getSelectionModel());
     nodeInfo.setDataDisplay(view);
@@ -872,6 +1027,18 @@
     return showMoreElem;
   }
 
+  /**
+   * Get a {@link TreeNode} with a public API for this node view.
+   *
+   * @return the {@link TreeNode}
+   */
+  TreeNode getTreeNode() {
+    if (treeNode == null) {
+      treeNode = new TreeNodeImpl(this);
+    }
+    return treeNode;
+  }
+
   int indexOf(CellTreeNodeView<?> child) {
     return children.indexOf(child);
   }
@@ -977,8 +1144,7 @@
    * @return true if the selection moved
    */
   boolean keyboardUp() {
-    Element prev =
-      keyboardSelection.getParentElement().getFirstChildElement();
+    Element prev = keyboardSelection.getParentElement().getFirstChildElement();
     Element next = prev.getNextSiblingElement();
     while (next != null && next != keyboardSelection) {
       prev = next;
@@ -997,8 +1163,8 @@
   void showFewer() {
     Range range = listView.getVisibleRange();
     int defaultPageSize = listView.getDefaultPageSize();
-    int maxSize = Math.max(defaultPageSize,
-        range.getLength() - defaultPageSize);
+    int maxSize = Math.max(
+        defaultPageSize, range.getLength() - defaultPageSize);
     listView.setVisibleRange(range.getStart(), maxSize);
   }
 
@@ -1036,8 +1202,8 @@
     boolean isTopLevel = parentNode.isRootNode();
     String html = tree.getClosedImageHtml(isTopLevel);
     if (open) {
-      html = isLoading ? tree.getLoadingImageHtml()
-          : tree.getOpenImageHtml(isTopLevel);
+      html = isLoading ? tree.getLoadingImageHtml() : tree.getOpenImageHtml(
+          isTopLevel);
     }
     if (nodeInfoLoaded && nodeInfo == null) {
       html = LEAF_IMAGE;
diff --git a/user/src/com/google/gwt/user/cellview/client/TreeNode.java b/user/src/com/google/gwt/user/cellview/client/TreeNode.java
new file mode 100644
index 0000000..c7eedab
--- /dev/null
+++ b/user/src/com/google/gwt/user/cellview/client/TreeNode.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.cellview.client;
+
+/**
+ * A representation of a node in a tree.
+ */
+public interface TreeNode {
+
+  /**
+   * Get the number of children of the node.
+   *
+   * @return the child count
+   */
+  int getChildCount();
+
+  /**
+   * Get the value associated with a child node.
+   *
+   * @return the value
+   */
+  Object getChildValue(int index);
+
+  /**
+   * Get the index of the current node relative to its parent.
+   *
+   * @return the index of the current node
+   */
+  int getIndex();
+
+  /**
+   * Get the parent node of this node.
+   *
+   * @return the parent node, or null if this node is the root node
+   */
+  TreeNode getParent();
+
+  /**
+   * Get the value associated with this node. This method can be called on
+   * destroyed nodes.
+   *
+   * @return the value
+   */
+  Object getValue();
+
+  /**
+   * Check whether or not a child node is a leaf node.
+   *
+   * @param index the index of the child
+   * @return true if a leaf node, false if not
+   */
+  boolean isChildLeaf(int index);
+
+  /**
+   * Check whether or not a child node is open.
+   *
+   * @param index the index of the child
+   * @return true if open, false if closed
+   */
+  boolean isChildOpen(int index);
+
+  /**
+   * Check whether or not the current node is destroyed. The node is destroyed
+   * when it is closed, even if it still appears in the tree as an unopened
+   * non-leaf node. Once a node is destroyed, calling most methods on the node
+   * results in an {@link IllegalStateException}.
+   *
+   * @return true if destroyed, false if active
+   */
+  boolean isDestroyed();
+
+  /**
+   * Open or close a child node and fire an event. If <code>open</code> is true
+   * and the {@link TreeNode} successfully opens, returns the child
+   * {@link TreeNode}. Delegates to {@link #setChildOpen(int,boolean, boolean)}.
+   *
+   * @param index the index of the child
+   * @param open true to open, false to close
+   * @return the {@link TreeNode} that was opened, or null if the node was
+   *         closed or could not be opened
+   */
+  TreeNode setChildOpen(int index, boolean open);
+
+  /**
+   * Open or close the node, optionally firing an event. If <code>open</code> is
+   * true and the {@link TreeNode} successfully opens, returns the child
+   * {@link TreeNode}.
+   *
+   * @param index the index of the child
+   * @param open true to open, false to flose
+   * @param fireEvents true to fire an event, false not to
+   * @return the {@link TreeNode} that was opened, or null if the node was
+   *         closed or could not be opened
+   */
+  TreeNode setChildOpen(int index, boolean open, boolean fireEvents);
+}
diff --git a/user/test/com/google/gwt/user/cellview/CellViewSuite.java b/user/test/com/google/gwt/user/cellview/CellViewSuite.java
index 836bf4d..2fe796b 100644
--- a/user/test/com/google/gwt/user/cellview/CellViewSuite.java
+++ b/user/test/com/google/gwt/user/cellview/CellViewSuite.java
@@ -17,6 +17,9 @@
 
 import com.google.gwt.junit.tools.GWTTestSuite;
 import com.google.gwt.user.cellview.client.AbstractPagerTest;
+import com.google.gwt.user.cellview.client.AnimatedCellTreeTest;
+import com.google.gwt.user.cellview.client.CellBrowserTest;
+import com.google.gwt.user.cellview.client.CellTreeTest;
 import com.google.gwt.user.cellview.client.ColumnTest;
 import com.google.gwt.user.cellview.client.HasDataPresenterTest;
 import com.google.gwt.user.cellview.client.PageSizePagerTest;
@@ -33,6 +36,9 @@
         "Test suite for all cellview classes");
 
     suite.addTestSuite(AbstractPagerTest.class);
+    suite.addTestSuite(AnimatedCellTreeTest.class);
+    suite.addTestSuite(CellBrowserTest.class);
+    suite.addTestSuite(CellTreeTest.class);
     suite.addTestSuite(ColumnTest.class);
     suite.addTestSuite(HasDataPresenterTest.class);
     suite.addTestSuite(PageSizePagerTest.class);
diff --git a/user/test/com/google/gwt/user/cellview/client/AbstractCellTreeTestBase.java b/user/test/com/google/gwt/user/cellview/client/AbstractCellTreeTestBase.java
new file mode 100644
index 0000000..1f57b59
--- /dev/null
+++ b/user/test/com/google/gwt/user/cellview/client/AbstractCellTreeTestBase.java
@@ -0,0 +1,606 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.cellview.client;
+
+import com.google.gwt.cell.client.Cell;
+import com.google.gwt.cell.client.TextCell;
+import com.google.gwt.event.logical.shared.CloseEvent;
+import com.google.gwt.event.logical.shared.CloseHandler;
+import com.google.gwt.event.logical.shared.OpenEvent;
+import com.google.gwt.event.logical.shared.OpenHandler;
+import com.google.gwt.junit.client.GWTTestCase;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.google.gwt.view.client.AbstractDataProvider;
+import com.google.gwt.view.client.ListDataProvider;
+import com.google.gwt.view.client.TreeViewModel;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Base tests for subclasses of {@link AbstractCellTree}.
+ */
+public abstract class AbstractCellTreeTestBase extends GWTTestCase {
+
+  /**
+   * The root value.
+   */
+  private static final Object ROOT_VALUE = new Object();
+
+  /**
+   * A mock {@link TreeViewModel} used for testing. Each child ads a character
+   * to the parent string. The longest string in the tree is 4 characters.
+   */
+  protected class MockTreeViewModel implements TreeViewModel {
+
+    /**
+     * The cell used to render all nodes in the tree.
+     */
+    private final Cell<String> cell = new TextCell();
+
+    /**
+     * The root data provider.
+     */
+    private final ListDataProvider<String> rootDataProvider =
+        createDataProvider("");
+
+    public <T> NodeInfo<?> getNodeInfo(T value) {
+      if (value == ROOT_VALUE) {
+        return new DefaultNodeInfo<String>(rootDataProvider, cell);
+      } else if (value instanceof String) {
+        String prefix = (String) value;
+        if (prefix.length() > 3) {
+          throw new IllegalStateException(
+              "Prefix should never exceed four characters.");
+        }
+        return new DefaultNodeInfo<String>(createDataProvider(prefix), cell);
+      }
+      throw new IllegalArgumentException("Unrecognized value type");
+    }
+
+    public boolean isLeaf(Object value) {
+      if (value == ROOT_VALUE) {
+        return false;
+      } else if (value instanceof String) {
+        String s = (String) value;
+        if (s.length() > 4) {
+          throw new IllegalStateException(
+              "value should never exceed five characters.");
+        }
+        return ((String) value).length() == 4;
+      }
+      throw new IllegalArgumentException("Unrecognized value type");
+    }
+
+    public AbstractDataProvider<String> getRootDataProvider() {
+      return rootDataProvider;
+    }
+
+    /**
+     * Create a data provider that extends the prefix by one letter.
+     *
+     * @param prefix the prefix string
+     * @return a data provider
+     */
+    private ListDataProvider<String> createDataProvider(String prefix) {
+      ListDataProvider<String> provider = new ListDataProvider<String>();
+      List<String> list = provider.getList();
+      for (int i = 0; i < 10; i++) {
+        list.add(prefix + ((char) ('a' + i)));
+      }
+      provider.flush();
+      return provider;
+    }
+  }
+
+  /**
+   * A mock {@link CloseHandler} used for testing.
+   */
+  private class MockCloseHandler implements CloseHandler<TreeNode> {
+
+    private CloseEvent<TreeNode> lastEvent;
+
+    public CloseEvent<TreeNode> getLastEventAndClear() {
+      CloseEvent<TreeNode> toRet = lastEvent;
+      lastEvent = null;
+      return toRet;
+    }
+
+    public void onClose(CloseEvent<TreeNode> event) {
+      assertNull(lastEvent);
+      this.lastEvent = event;
+    }
+  }
+
+  /**
+   * A mock {@link OpenHandler} used for testing.
+   */
+  private class MockOpenHandler implements OpenHandler<TreeNode> {
+
+    private OpenEvent<TreeNode> lastEvent;
+
+    public OpenEvent<TreeNode> getLastEventAndClear() {
+      OpenEvent<TreeNode> toRet = lastEvent;
+      lastEvent = null;
+      return toRet;
+    }
+
+    public void onOpen(OpenEvent<TreeNode> event) {
+      assertNull(lastEvent);
+      this.lastEvent = event;
+    }
+  }
+
+  /**
+   * The model that backs the tree.
+   */
+  protected MockTreeViewModel model;
+
+  /**
+   * The current tree being tested.
+   */
+  protected AbstractCellTree tree;
+
+  /**
+   * If true, the tree only supports opening a single path.
+   */
+  private final boolean singlePathOnly;
+
+  /**
+   * Construct a new {@link AbstractCellTreeTestBase}.
+   *
+   * @param singlePathOnly true if the tree only supports a single open path
+   */
+  public AbstractCellTreeTestBase(boolean singlePathOnly) {
+    this.singlePathOnly = singlePathOnly;
+  }
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.user.cellview.CellView";
+  }
+
+  public void testGetRootNode() {
+    TreeNode root = tree.getRootTreeNode();
+    assertEquals(10, root.getChildCount());
+    assertEquals(0, root.getIndex());
+    assertNull(root.getParent());
+    assertEquals(ROOT_VALUE, root.getValue());
+    testTreeNode(root, null, 0, ROOT_VALUE, false);
+  }
+
+  public void testIsLeaf() {
+    assertFalse(tree.isLeaf(ROOT_VALUE));
+    assertFalse(tree.isLeaf("a"));
+    assertFalse(tree.isLeaf("ab"));
+    assertFalse(tree.isLeaf("ab"));
+    assertFalse(tree.isLeaf("abc"));
+    assertTrue(tree.isLeaf("abcd"));
+  }
+
+  /**
+   * Test that opening a sibling node works.
+   */
+  public void testOpenSiblingNode() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Open a node.
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(b, openHandler.getLastEventAndClear().getTarget());
+
+    // Open a sibling node.
+    TreeNode d = root.setChildOpen(3, true);
+    if (singlePathOnly) {
+      assertFalse(root.isChildOpen(1));
+      assertEquals(b, closeHandler.getLastEventAndClear().getTarget());
+    } else {
+      assertTrue(root.isChildOpen(1));
+      assertNull(closeHandler.getLastEventAndClear());
+    }
+    assertEquals(d, openHandler.getLastEventAndClear().getTarget());
+    assertTrue(root.isChildOpen(3));
+  }
+
+  /**
+   * Test a {@link TreeNode} at the leaf. We access the leaf nodes with the
+   * {@link TreeNode} that is the parent of the leaf nodes.
+   */
+  public void testTreeNodeAtLeaf() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Walk to a parent of leaf nodes.
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(b, openHandler.getLastEventAndClear().getTarget());
+    TreeNode bc = b.setChildOpen(2, true);
+    assertEquals(bc, openHandler.getLastEventAndClear().getTarget());
+    TreeNode bce = bc.setChildOpen(4, true);
+    assertEquals(bce, openHandler.getLastEventAndClear().getTarget());
+
+    // Try to open the leaf.
+    assertNull(bce.setChildOpen(0, true));
+    assertNull(openHandler.getLastEventAndClear());
+    assertNull(openHandler.getLastEventAndClear());
+
+    // Test the values associated with the node.
+    testTreeNode(bce, bc, 4, "bce", true);
+  }
+
+  /**
+   * Test a {@link TreeNode} in the middle of the tree.
+   */
+  public void testTreeNodeAtMiddle() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Walk to a parent of leaf nodes.
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(b, openHandler.getLastEventAndClear().getTarget());
+    TreeNode bc = b.setChildOpen(2, true);
+    assertEquals(bc, openHandler.getLastEventAndClear().getTarget());
+
+    // Test the values associated with the node.
+    testTreeNode(bc, b, 2, "bc", false);
+  }
+
+  /**
+   * Test that closing a branch closes all open nodes recursively.
+   */
+  public void testTreeNodeCloseBranch() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Walk down a branch.
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(b, openHandler.getLastEventAndClear().getTarget());
+    TreeNode bc = b.setChildOpen(2, true);
+    assertEquals(bc, openHandler.getLastEventAndClear().getTarget());
+    TreeNode bce = bc.setChildOpen(4, true);
+    assertEquals(bce, openHandler.getLastEventAndClear().getTarget());
+
+    // Close the node at the top of the branch.
+    assertNull(root.setChildOpen(1, false));
+    assertFalse(root.isChildOpen(1));
+    assertTrue(b.isDestroyed());
+    assertTrue(bc.isDestroyed());
+    assertTrue(bce.isDestroyed());
+    assertNull(openHandler.getLastEventAndClear());
+    assertEquals(b, closeHandler.getLastEventAndClear().getTarget());
+  }
+
+  public void testTreeNodeCloseChild() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler() {
+      @Override
+      public void onClose(CloseEvent<TreeNode> event) {
+        super.onClose(event);
+
+        // The node should be destroyed when the close event is fired.
+        TreeNode node = event.getTarget();
+        assertTrue(node.isDestroyed());
+      }
+    };
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Open a node.
+    TreeNode child = root.setChildOpen(2, true);
+    assertEquals(child, openHandler.getLastEventAndClear().getTarget());
+    assertNull(closeHandler.getLastEventAndClear());
+    assertTrue(root.isChildOpen(2));
+    assertFalse(child.isDestroyed());
+    assertEquals("c", child.getValue());
+    assertEquals(2, child.getIndex());
+    assertEquals(root, child.getParent());
+
+    // Close the child.
+    assertNull(root.setChildOpen(2, false));
+    assertNull(openHandler.getLastEventAndClear());
+    assertEquals(child, closeHandler.getLastEventAndClear().getTarget());
+    assertFalse(root.isChildOpen(2));
+    assertFalse(root.isDestroyed());
+    assertTrue(child.isDestroyed());
+  }
+
+  public void testTreeNodeCloseChildAlreadyClosed() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Open a node.
+    TreeNode child = root.setChildOpen(2, true);
+    assertEquals(child, openHandler.getLastEventAndClear().getTarget());
+    assertNull(closeHandler.getLastEventAndClear());
+    assertTrue(root.isChildOpen(2));
+    assertFalse(child.isDestroyed());
+    assertEquals("c", child.getValue());
+    assertEquals(2, child.getIndex());
+    assertEquals(root, child.getParent());
+
+    // Close the child.
+    assertNull(root.setChildOpen(2, false));
+    assertNull(openHandler.getLastEventAndClear());
+    assertEquals(child, closeHandler.getLastEventAndClear().getTarget());
+    assertFalse(root.isChildOpen(2));
+    assertFalse(root.isDestroyed());
+    assertTrue(child.isDestroyed());
+
+    // Close the child again.
+    assertNull(root.setChildOpen(2, false));
+    assertNull(openHandler.getLastEventAndClear());
+    assertNull(closeHandler.getLastEventAndClear());
+    assertFalse(root.isChildOpen(2));
+    assertFalse(root.isDestroyed());
+    assertTrue(child.isDestroyed());
+  }
+
+  /**
+   * Test that a tree node is destroyed if its associated data is lost when new
+   * data is provided to the node.
+   */
+  public void testTreeNodeDataLost() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Get a node.
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(b, openHandler.getLastEventAndClear().getTarget());
+
+    // Replace the data without the old node.
+    List<String> list = new ArrayList<String>();
+    list.add("x");
+    list.add("y");
+    list.add("z");
+    model.rootDataProvider.setList(list);
+
+    // Verify the node is destroyed.
+    assertTrue(b.isDestroyed());
+  }
+
+  /**
+   * Test that a tree node continues to exist when new data is pushed to the
+   * node.
+   */
+  public void testTreeNodeDataReplaced() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Get a node.
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(b, openHandler.getLastEventAndClear().getTarget());
+
+    // Replace the data and include the old node at a different location.
+    List<String> list = new ArrayList<String>();
+    list.add("x");
+    list.add("y");
+    list.add("b");
+    list.add("z");
+    model.rootDataProvider.setList(list);
+
+    // Verify the node still exists.
+    assertFalse(root.isChildOpen(1));
+    assertTrue(root.isChildOpen(2));
+    testTreeNode(b, root, 2, "b", false);
+  }
+
+  public void testTreeNodeIsDestroyed() {
+    TreeNode root = tree.getRootTreeNode();
+
+    // Open a node.
+    TreeNode c = root.setChildOpen(2, true);
+    assertFalse(c.isDestroyed());
+
+    // Close the node.
+    assertNull(root.setChildOpen(2, false));
+    assertFalse(root.isDestroyed());
+    assertTrue(c.isDestroyed());
+
+    // Verify we can still get the value.
+    assertEquals("c", c.getValue());
+
+    try {
+      c.getChildCount();
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+    try {
+      c.getChildValue(0);
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+    try {
+      c.getIndex();
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+    try {
+      c.getParent();
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+    try {
+      c.isChildLeaf(0);
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+    try {
+      c.setChildOpen(0, true);
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+    try {
+      c.setChildOpen(0, true, true);
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException e) {
+      // Expected;
+    }
+  }
+
+  /**
+   * Try to open a child that is already open.
+   */
+  public void testTreeNodeOpenChildAlreadyOpen() {
+    MockOpenHandler openHandler = new MockOpenHandler();
+    MockCloseHandler closeHandler = new MockCloseHandler();
+    tree.addOpenHandler(openHandler);
+    tree.addCloseHandler(closeHandler);
+    TreeNode root = tree.getRootTreeNode();
+
+    // Open a node.
+    TreeNode child = root.setChildOpen(2, true);
+    assertEquals(child, openHandler.getLastEventAndClear().getTarget());
+    assertNull(closeHandler.getLastEventAndClear());
+    assertTrue(root.isChildOpen(2));
+    assertFalse(child.isDestroyed());
+    assertEquals("c", child.getValue());
+    assertEquals(2, child.getIndex());
+    assertEquals(root, child.getParent());
+
+    // Open the same node.
+    assertEquals(child, root.setChildOpen(2, true));
+    assertNull(openHandler.getLastEventAndClear());
+    assertNull(closeHandler.getLastEventAndClear());
+    assertTrue(root.isChildOpen(2));
+    assertFalse(child.isDestroyed());
+  }
+
+  /**
+   * Create an {@link AbstractCellTree} to test.
+   *
+   * @param <T> the data type of the root value
+   * @param model the {@link TreeViewModel} that backs the tree
+   * @param rootValue the root value
+   * @return a new {@link AbstractCellTree}
+   */
+  protected abstract <T> AbstractCellTree createAbstractCellTree(
+      TreeViewModel model, T rootValue);
+
+  @Override
+  protected void gwtSetUp() throws Exception {
+    model = new MockTreeViewModel();
+    tree = createAbstractCellTree(model, ROOT_VALUE);
+    RootPanel.get().add(tree);
+  }
+
+  @Override
+  protected void gwtTearDown() throws Exception {
+    RootPanel.get().remove(tree);
+  }
+
+  /**
+   * Test the state of a {@link TreeNode}.
+   *
+   * @param node the node to test
+   * @param parent the expected parent
+   * @param index the expected index within the parent
+   * @param value the expected value
+   * @param isChildLeaf true if the node only contains leaf nodes
+   */
+  private void testTreeNode(TreeNode node, TreeNode parent, int index,
+      Object value, boolean isChildLeaf) {
+    assertEquals(10, node.getChildCount());
+    assertEquals(index, node.getIndex());
+    assertEquals(parent, node.getParent());
+    assertEquals(value, node.getValue());
+
+    // Test child values.
+    String prefix = (value == ROOT_VALUE) ? "" : value.toString();
+    assertEquals(prefix + "a", node.getChildValue(0));
+    assertEquals(prefix + "j", node.getChildValue(9));
+    for (int i = 0; i < 10; i++) {
+      assertEquals(isChildLeaf, node.isChildLeaf(i));
+      assertFalse(node.isChildOpen(i));
+    }
+
+    // Test children out of range.
+    try {
+      node.getChildValue(-1);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.getChildValue(10);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.isChildLeaf(-1);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.isChildLeaf(10);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.isChildOpen(-1);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.isChildOpen(10);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.setChildOpen(-1, true);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+    try {
+      node.setChildOpen(10, true);
+      fail("Expected IndexOutOfBoundsException");
+    } catch (IndexOutOfBoundsException e) {
+      // Expected.
+    }
+  }
+}
diff --git a/user/test/com/google/gwt/user/cellview/client/AnimatedCellTreeTest.java b/user/test/com/google/gwt/user/cellview/client/AnimatedCellTreeTest.java
new file mode 100644
index 0000000..b636acf
--- /dev/null
+++ b/user/test/com/google/gwt/user/cellview/client/AnimatedCellTreeTest.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.cellview.client;
+
+import com.google.gwt.view.client.TreeViewModel;
+
+/**
+ * Tests for {@link CellTree} with animations enabled.
+ */
+public class AnimatedCellTreeTest extends CellTreeTest {
+
+  @Override
+  protected <T> CellTree createAbstractCellTree(
+      TreeViewModel model, T rootValue) {
+    CellTree tree = super.createAbstractCellTree(model, rootValue);
+    tree.setAnimationEnabled(true);
+    return tree;
+  }
+}
diff --git a/user/test/com/google/gwt/user/cellview/client/CellBrowserTest.java b/user/test/com/google/gwt/user/cellview/client/CellBrowserTest.java
new file mode 100644
index 0000000..afe60a7
--- /dev/null
+++ b/user/test/com/google/gwt/user/cellview/client/CellBrowserTest.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.cellview.client;
+
+import com.google.gwt.view.client.TreeViewModel;
+
+/**
+ * Tests for {@link CellBrowser}.
+ */
+public class CellBrowserTest extends AbstractCellTreeTestBase {
+
+  public CellBrowserTest() {
+    super(true);
+  }
+
+  @Override
+  protected <T> CellBrowser createAbstractCellTree(
+      TreeViewModel model, T rootValue) {
+    CellBrowser browser = new CellBrowser(model, rootValue);
+    browser.setHeight("500px");
+    return browser;
+  }
+}
diff --git a/user/test/com/google/gwt/user/cellview/client/CellTreeTest.java b/user/test/com/google/gwt/user/cellview/client/CellTreeTest.java
new file mode 100644
index 0000000..07f5886
--- /dev/null
+++ b/user/test/com/google/gwt/user/cellview/client/CellTreeTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.cellview.client;
+
+import com.google.gwt.view.client.TreeViewModel;
+
+/**
+ * Tests for {@link CellTree}.
+ */
+public class CellTreeTest extends AbstractCellTreeTestBase {
+
+  public CellTreeTest() {
+    super(false);
+  }
+
+  public void testSetDefaultNodeSize() {
+    CellTree cellTree = (CellTree) tree;
+    TreeNode root = cellTree.getRootTreeNode();
+    assertEquals(10, root.getChildCount());
+
+    TreeNode b = root.setChildOpen(1, true);
+    assertEquals(10, b.getChildCount());
+
+    // Change the default size.
+    cellTree.setDefaultNodeSize(5);
+    assertEquals(5, cellTree.getDefaultNodeSize());
+    assertEquals(10, b.getChildCount());
+    TreeNode d = root.setChildOpen(3, true);
+    assertEquals(5, d.getChildCount());
+  }
+
+  @Override
+  protected <T> CellTree createAbstractCellTree(
+      TreeViewModel model, T rootValue) {
+    return new CellTree(model, rootValue);
+  }
+}