Performance improvements: Handler have become non-static members of tree nodes and cache data to prevent UNO queries. Increased type safety by introduction of tree node hierarchy.

20 files changed, 1369 insertions, 667 deletions

diff --git a/toolkit/test/accessibility/AccTreeNode.java b/toolkit/test/accessibility/AccTreeNode.java
index c8c861d6a77e..752db6692241 100644
--- a/toolkit/test/accessibility/AccTreeNode.java
+++ b/toolkit/test/accessibility/AccTreeNode.java
@@ -1,4 +1,6 @@
-
+import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessible;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import java.util.Vector;
 
 /**
@@ -8,92 +10,188 @@ import java.util.Vector;
  * type.
  */
 class AccTreeNode
+    extends AccessibleTreeNode
 {
-    private Vector aHandlers;       /// NodeHandlers for this node
-    private Object aDataObject;     /// the actual data object
-    private Object aDisplayObject;  /// object to be displayed
+    class HandlerDescriptor
+    {
+        public HandlerDescriptor (NodeHandler aHandler)
+        {
+            maHandler = aHandler;
+            mnChildCount = -1;
+        }
+        public NodeHandler maHandler;
+        public int mnChildCount;
+    }
+    /// NodeHandlers for this node
+    private Vector maHandlers;
+
+    // The accessible context of this node.
+    private XAccessible mxAccessible;
+    private XAccessibleContext mxContext;
+
+    public AccTreeNode (XAccessibleContext xContext, AccessibleTreeNode aParent)
+    {
+        this (xContext, xContext, aParent);
+    }
 
-    public AccTreeNode( Object aData )
+    public AccTreeNode (XAccessibleContext xContext, Object aDisplay, AccessibleTreeNode aParent)
     {
-        this( aData, aData );
+        super (aDisplay, aParent);
+
+        maHandlers = new Vector(5);
+        mxContext = xContext;
+        mxAccessible = null;
     }
 
-    public AccTreeNode( Object aData, Object aDisplay )
+    /** Update the internal data extracted from the corresponding accessible
+        object.  This is done by replacing every handler by a new one.  An
+        update method at each handler would be better of course.
+    */
+    public void update ()
     {
-        aHandlers = new Vector();
-        aDataObject = aData;
-        aDisplayObject = aDisplay;
+        for (int i=0; i<maHandlers.size(); i++)
+        {
+            System.out.println ("replacing handler " + i);
+            HandlerDescriptor aDescriptor = (HandlerDescriptor)maHandlers.get(i);
+            aDescriptor.maHandler = aDescriptor.maHandler.createHandler (mxContext);
+            aDescriptor.mnChildCount =
+                    aDescriptor.maHandler.getChildCount (this);
+        }
     }
 
-    public Object getDataObject() { return aDataObject; }
-    public Object getDisplayObject() { return aDisplayObject; }
+    public XAccessibleContext getContext()
+    {
+        return mxContext;
+    }
+
+    public XAccessible getAccessible()
+    {
+        if ((mxAccessible == null) && (mxContext != null))
+            mxAccessible = (XAccessible)UnoRuntime.queryInterface(
+                XAccessible.class, mxContext);
+        return mxAccessible;
+    }
 
     public void addHandler( NodeHandler aHandler )
     {
-        aHandlers.add( aHandler );
+        if (aHandler != null)
+            maHandlers.add (new HandlerDescriptor (aHandler));
     }
 
 
     /** iterate over handlers and return child sum */
+    protected HandlerDescriptor getHandlerDescriptor (int i)
+    {
+        HandlerDescriptor aDescriptor = (HandlerDescriptor)maHandlers.get(i);
+        if (aDescriptor.mnChildCount < 0)
+            aDescriptor.mnChildCount =
+                    aDescriptor.maHandler.getChildCount (this);
+        return aDescriptor;
+    }
+
     public int getChildCount()
     {
-        int nRet = 0;
-        for(int i = 0; i < aHandlers.size(); i++)
+        int nChildCount = 0;
+        for (int i = 0; i < maHandlers.size(); i++)
         {
-            nRet += ((NodeHandler)aHandlers.get(i)).
-                getChildCount( aDataObject );
+            HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+            nChildCount += aDescriptor.mnChildCount;
         }
-        return nRet;
+        return nChildCount;
     }
 
     /** iterate over handlers until the child is found */
-    public Object getChild(int nIndex)
+    public AccessibleTreeNode getChild (int nIndex)
+        throws IndexOutOfBoundsException
     {
         if( nIndex >= 0 )
         {
-            for(int i = 0; i < aHandlers.size(); i++)
+            for(int i = 0; i < maHandlers.size(); i++)
             {
                 // check if this handler has the child, and if not
                 // search with next handler
-                NodeHandler aHandler = (NodeHandler)aHandlers.get(i);
-                int nCount = aHandler.getChildCount( aDataObject );
-                if( nCount > nIndex )
-                    return aHandler.getChild( aDataObject, nIndex );
+                HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+                if (nIndex < aDescriptor.mnChildCount)
+                    return aDescriptor.maHandler.getChild (this, nIndex);
                 else
-                    nIndex -= nCount;
+                    nIndex -= aDescriptor.mnChildCount;
             }
         }
+        else
+            throw new IndexOutOfBoundsException();
 
         // nothing found?
         return null;
     }
 
+    public boolean removeChild (int nIndex)
+        throws IndexOutOfBoundsException
+    {
+        boolean bStatus = false;
+        if (nIndex >= 0)
+        {
+            for (int i=0; i<maHandlers.size(); i++)
+            {
+                // check if this handler has the child, and if not
+                // search with next handler
+                HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+                if (nIndex < aDescriptor.mnChildCount)
+                {
+                    bStatus = aDescriptor.maHandler.removeChild (this, nIndex);
+                    aDescriptor.mnChildCount = aDescriptor.maHandler.getChildCount (this);
+                    break;
+                }
+                else
+                    nIndex -= aDescriptor.mnChildCount;
+            }
+        }
+        else
+            throw new IndexOutOfBoundsException();
+
+        return bStatus;
+    }
+
 
-    /** this node is a leaf if have no handlers, or is those
-            handlers show no children */
-    public boolean isLeaf()
+    public int indexOf (AccessibleTreeNode aNode)
     {
-        return (aHandlers.size() == 0) || (getChildCount() == 0);
+        int nBaseIndex = 0;
+        if (aNode != null)
+        {
+            for (int i=0; i<maHandlers.size(); i++)
+            {
+                HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+                int nIndex = aDescriptor.maHandler.indexOf (aNode);
+                if (nIndex >= 0)
+                    return nBaseIndex + nIndex;
+                else
+                    nBaseIndex += aDescriptor.mnChildCount;
+            }
+        }
+
+        return -1;
     }
 
-    public boolean equals(Object aOther)
+    /** this node is a leaf if have no handlers, or is those
+            handlers show no children */
+    public boolean isLeaf()
     {
-        return (this == aOther) || aOther.equals( aDataObject );
+        return (maHandlers.size() == 0);// || (getChildCount() == 0);
     }
 
-    public String toString()
+    public boolean equals (Object aOther)
     {
-        return aDisplayObject.toString();
+        return (this == aOther) || aOther.equals(mxContext);
     }
 
 
     /** iterate over handlers until the child is found */
     public void getActions(Vector aActions)
     {
-        for(int i = 0; i < aHandlers.size(); i++)
+        for(int i = 0; i < maHandlers.size(); i++)
         {
-            NodeHandler aHandler = (NodeHandler)aHandlers.get(i);
-            String[] aHandlerActions = aHandler.getActions( aDataObject );
+            HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+            NodeHandler aHandler = aDescriptor.maHandler;
+            String[] aHandlerActions = aHandler.getActions (this);
             for(int j = 0; j < aHandlerActions.length; j++ )
             {
                 aActions.add( aHandlerActions[j] );
@@ -105,15 +203,16 @@ class AccTreeNode
     {
         if( nIndex >= 0 )
         {
-            for(int i = 0; i < aHandlers.size(); i++)
+            for(int i = 0; i < maHandlers.size(); i++)
             {
                 // check if this handler has the child, and if not
                 // search with next handler
-                NodeHandler aHandler = (NodeHandler)aHandlers.get(i);
-                int nCount = aHandler.getActions( aDataObject ).length;
+                HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+                NodeHandler aHandler = aDescriptor.maHandler;
+                int nCount = aHandler.getActions(this).length;
                 if( nCount > nIndex )
                 {
-                    aHandler.performAction( aDataObject, nIndex );
+                    aHandler.performAction(this, nIndex );
                     return;
                 }
                 else
@@ -122,4 +221,24 @@ class AccTreeNode
         }
     }
 
+    /** Try to add the specified accessible object as new accessible child of the
+        AccessibleTreeHandler.
+        Note that child is used in another context than
+        it is used in the other methods of this class.
+    */
+    public AccessibleTreeNode addAccessibleChild (XAccessible xChild)
+    {
+        for(int i = 0; i < maHandlers.size(); i++)
+        {
+            HandlerDescriptor aDescriptor = getHandlerDescriptor (i);
+            if (aDescriptor.maHandler instanceof AccessibleTreeHandler)
+            {
+                AccessibleTreeHandler aHandler = (AccessibleTreeHandler)aDescriptor.maHandler;
+                AccessibleTreeNode aNode = aHandler.addAccessibleChild (this, xChild);
+                aDescriptor.mnChildCount = aHandler.getChildCount (this);
+                return aNode;
+            }
+        }
+        return null;
+    }
 }
diff --git a/toolkit/test/accessibility/AccessibilityTree.java b/toolkit/test/accessibility/AccessibilityTree.java
index abaedfcbfcaa..5342b9e5365c 100755
--- a/toolkit/test/accessibility/AccessibilityTree.java
+++ b/toolkit/test/accessibility/AccessibilityTree.java
@@ -42,12 +42,14 @@ public class AccessibilityTree
     */
     public AccessibilityTree (
         MessageInterface aMessageDisplay,
-        Canvas aCanvas)
+        Canvas aCanvas,
+        Print aPrinter)
     {
         maMessageDisplay = aMessageDisplay;
         maCanvas = aCanvas;
+        maPrinter = aPrinter;
 
-        setModel( new AccessibilityTreeModel( "Please press Update button" ) );
+        setModel( new AccessibilityTreeModel( "Please press Update button", aMessageDisplay, aPrinter) );
 
         maCellRenderer = new AccessibleTreeCellRenderer();
         //        setCellRenderer (maCellRenderer);
@@ -56,7 +58,7 @@ public class AccessibilityTree
         //        setEditable (true);
         //        maTreeModel.addTreeModelListener( new TextUpdateListener() );
 
-        addMouseListener( new MouseListener() );
+        addMouseListener (new MouseListener (this));
     }
 
 
@@ -76,48 +78,84 @@ public class AccessibilityTree
     /** expand all nodes with accessibility roles > 100 */
     class ShapeExpander extends Expander
     {
-        public boolean expand(Object aObject)
+        public boolean expand (Object aObject)
         {
-            aObject = AccessibilityTreeModel.normalize( aObject );
-            XAccessibleContext xContext =
-                (XAccessibleContext)UnoRuntime.queryInterface(
-                     XAccessibleContext.class, aObject );
-            int nRole = ( xContext == null ) ? -1 :
-                xContext.getAccessibleRole();
-            return (nRole >= 100);
+            if (aObject instanceof AccTreeNode)
+            {
+                AccTreeNode aNode = (AccTreeNode)aObject;
+                XAccessibleContext xContext = aNode.getContext();
+                if (xContext != null)
+                    if (xContext.getAccessibleRole() >= 100)
+                        return true;
+            }
+            return false;
         }
     }
 
+    /** Expand the nodes in the subtree rooted in aNode according to the the
+        specified expander.  The tree is locked during the expansion.
+    */
+    protected void expandTree (AccessibleTreeNode aNode, Expander aExpander)
+    {
+        message ("Expanding tree");
+        maPrinter.println ("Expanding tree:");
+        setEnabled (false);
+        ((AccessibilityTreeModel)getModel()).lock ();
+
+        try
+        {
+            expandTree (new TreePath (aNode.createPath()), aExpander);
+        }
+        catch (Exception e)
+        {
+            // Ignore
+        }
+
+        setEnabled (true);
+        ((AccessibilityTreeModel)getModel()).unlock (aNode);
+        maPrinter.println ("Done.");
+        message ("");
+    }
+
     private TreePath expandTree( TreePath aPath, Expander aExpander )
     {
         // return first expanded object
         TreePath aFirst = null;
 
-        // get 'our' object
-        Object aObj = aPath.getLastPathComponent();
+        //        System.out.print ("e");
 
-        // expand this object, if the Expander tells us so
-        if( aExpander.expand( aObj ) )
+        try
         {
-            expandPath (aPath);
-            if( aFirst == null )
-                aFirst = aPath;
-        }
+            // get 'our' object
+            Object aObj = aPath.getLastPathComponent();
 
-        // visit all children
-        if( aObj instanceof AccTreeNode )
-        {
-            AccTreeNode aNode = (AccTreeNode)aObj;
-            int nLength = aNode.getChildCount();
-            for( int i = 0; i < nLength; i++ )
+            // expand this object, if the Expander tells us so
+            if( aExpander.expand( aObj ) )
             {
-                TreePath aRet = expandTree(
-                    aPath.pathByAddingChild( aNode.getChild( i ) ),
-                    aExpander );
+                expandPath (aPath);
                 if( aFirst == null )
-                    aFirst = aRet;
+                    aFirst = aPath;
+            }
+
+            // visit all children
+            if (aObj instanceof AccessibleTreeNode)
+            {
+                AccessibleTreeNode aNode = (AccessibleTreeNode)aObj;
+                int nLength = aNode.getChildCount();
+                for( int i = 0; i < nLength; i++ )
+                {
+                    TreePath aRet = expandTree(
+                        aPath.pathByAddingChild( aNode.getChild( i ) ),
+                        aExpander );
+                    if( aFirst == null )
+                        aFirst = aRet;
+                }
             }
         }
+        catch (Exception e)
+        {
+            System.out.println ("caught exception while expanding tree path " + aPath + ": " + e);
+        }
 
         return aFirst;
     }
@@ -127,21 +165,25 @@ public class AccessibilityTree
      *  this method from the outside. */
     public void expandShapes ()
     {
-        message ("Expanding shapes.");
-
-        TreePath aFirst = expandTree( new TreePath( getModel().getRoot() ),
-                                      new ShapeExpander() );
-        if( aFirst != null )
-        {
-            makeVisible (aFirst);
-        }
+        expandShapes ((AccessibleTreeNode)getModel().getRoot());
+    }
+    public void expandShapes (AccessibleTreeNode aNode)
+    {
+        expandTree (
+            new TreePath (aNode.createPath()),
+            new ShapeExpander());
     }
 
     /** Expand all nodes */
     public void expandAll ()
     {
-        message ("Expanding complete tree");
-        expandTree( new TreePath( getModel().getRoot() ), new AllExpander() );
+        expandAll ((AccessibleTreeNode)getModel().getRoot());
+    }
+    public void expandAll (AccessibleTreeNode aNode)
+    {
+        expandTree(
+            new TreePath (aNode.createPath()),
+            new AllExpander() );
     }
 
 
@@ -160,6 +202,8 @@ public class AccessibilityTree
 
     class MouseListener extends MouseAdapter
     {
+        private AccessibilityTree maTree;
+        public MouseListener (AccessibilityTree aTree) {maTree=aTree;}
         public void mousePressed(MouseEvent e) { popupTrigger(e); }
         public void mouseClicked(MouseEvent e) { popupTrigger(e); }
         public void mouseEntered(MouseEvent e) { popupTrigger(e); }
@@ -172,28 +216,32 @@ public class AccessibilityTree
             if( bIsPopup )
             {
                 int selRow = getRowForLocation(e.getX(), e.getY());
-                TreePath aPath = getPathForLocation(e.getX(), e.getY());
-
-                // check for actions
-                Object aObject = aPath.getLastPathComponent();
-                if( aObject instanceof AccTreeNode )
+                if (selRow != -1)
                 {
-                    AccTreeNode aNode = (AccTreeNode)aObject;
-
-                    JPopupMenu aMenu = new JPopupMenu();
+                    TreePath aPath = getPathForLocation(e.getX(), e.getY());
 
-                    Vector aActions = new Vector();
-                    aNode.getActions(aActions);
-                    for( int i = 0; i < aActions.size(); i++ )
+                    // check for actions
+                    Object aObject = aPath.getLastPathComponent();
+                    if( aObject instanceof AccTreeNode )
                     {
-                        aMenu.add( new NodeAction(
-                            aActions.elementAt(i).toString(),
-                            aNode, i ) );
-                    }
+                        AccTreeNode aNode = (AccTreeNode)aObject;
+
+                        JPopupMenu aMenu = new JPopupMenu();
+
+                        Vector aActions = new Vector();
+                        aMenu.add (new ShapeExpandAction(maTree, aNode));
+                        aMenu.add (new SubtreeExpandAction(maTree, aNode));
+
+                        aNode.getActions(aActions);
+                        for( int i = 0; i < aActions.size(); i++ )
+                        {
+                            aMenu.add( new NodeAction(
+                                           aActions.elementAt(i).toString(),
+                                           aNode, i ) );
+                        }
 
-                    // show menu (if we have actions)
-                    if( aActions.size() > 0 )
                         aMenu.show( AccessibilityTree.this, e.getX(), e.getY() );
+                    }
                 }
             }
 
@@ -218,6 +266,38 @@ public class AccessibilityTree
             maNode.performAction(mnIndex);
         }
     }
+    // This action expands all shapes in the subtree rooted in the specified node.
+    class ShapeExpandAction extends AbstractAction
+    {
+        private AccessibilityTree maTree;
+        private AccTreeNode maNode;
+        public ShapeExpandAction (AccessibilityTree aTree, AccTreeNode aNode)
+        {
+            super ("Expand Shapes");
+            maTree = aTree;
+            maNode = aNode;
+        }
+        public void actionPerformed (ActionEvent e)
+        {
+            maTree.expandShapes (maNode);
+        }
+    }
+    // This action expands all nodes in the subtree rooted in the specified node.
+    class SubtreeExpandAction extends AbstractAction
+    {
+        private AccessibilityTree maTree;
+        private AccTreeNode maNode;
+        public SubtreeExpandAction (AccessibilityTree aTree, AccTreeNode aNode)
+        {
+            super ("Expand Subtree");
+            maTree = aTree;
+            maNode = aNode;
+        }
+        public void actionPerformed (ActionEvent e)
+        {
+            maTree.expandAll (maNode);
+        }
+    }
 
 
     /** listen to tree model changes in order to update XAccessibleText objects
@@ -381,6 +461,8 @@ public class AccessibilityTree
 
     protected MessageInterface
         maMessageDisplay;
+    protected Print
+        maPrinter;
     protected AccessibleTreeCellRenderer
         maCellRenderer;
 
diff --git a/toolkit/test/accessibility/AccessibilityTreeModel.java b/toolkit/test/accessibility/AccessibilityTreeModel.java
index ab933df174df..f005df4c8e9b 100644
--- a/toolkit/test/accessibility/AccessibilityTreeModel.java
+++ b/toolkit/test/accessibility/AccessibilityTreeModel.java
@@ -20,18 +20,45 @@ import com.sun.star.lang.XServiceInfo;
 public class AccessibilityTreeModel
     implements TreeModel, XAccessibleEventListener
 {
-    public AccessibilityTreeModel( Object aRoot )
+    // Map to translate from accessible object to corresponding tree node.
+    protected HashMap maXAccessibleToNode;
+
+    // Making both of these static is clearly a hack.
+    protected static MessageInterface maMessageArea;
+    protected static Print maPrinter;
+    protected static boolean mbVerbose = true;
+
+    // If the lock count is higher then zero, then no events are processed.
+    private int mnLockCount;
+
+    // The list of TreeModelListener objects.
+    private Vector maTMListeners;
+
+    // default handlers, Vector<HandlerPair>
+    private static Vector aDefaultHandlers;
+    private static NodeHandler maContextHandler = new AccessibleContextHandler();
+    private static NodeHandler maTextHandler = new AccessibleTextHandler();
+    private static NodeHandler maEditableTextHandler = new AccessibleEditableTextHandler();
+    private static NodeHandler maComponentHandler = new AccessibleComponentHandler();
+    private static NodeHandler maExtendedComponentHandler = new AccessibleExtendedComponentHandler();
+    private static NodeHandler maActionHandler = new AccessibleActionHandler();
+    private static NodeHandler maImageHandler = new AccessibleImageHandler();
+    private static NodeHandler maTableHandler = new AccessibleTableHandler();
+    private static NodeHandler maHypertextHandler = new AccessibleHypertextHandler();
+    private static NodeHandler maHyperlinkHandler = new AccessibleHyperlinkHandler();
+    private static NodeHandler maTreeHandler = new AccessibleTreeHandler();
+
+    public AccessibilityTreeModel (Object aRoot, MessageInterface aMessageArea, Print aPrinter)
     {
         // create default node (unless we have a 'proper' node)
-        if( ! (aRoot instanceof AccTreeNode) )
-            aRoot = createDefaultNode( aRoot );
+        if( ! (aRoot instanceof AccessibleTreeNode) )
+            aRoot = new StringNode ("Root", null);
         maRoot = aRoot;
+        maMessageArea = aMessageArea;
+        maPrinter = aPrinter;
 
-        aListeners = new Vector();
-        aParents = new HashMap();
-        aChildren = new HashMap();
-        aNodes = new HashMap();
-        aNodes.put( normalize(maRoot), maRoot );
+        maTMListeners = new Vector();
+        maXAccessibleToNode = new HashMap ();
 
         // syncronous or asyncronous event delivery? (i.e. same thread
         // or in s seperate event delivery thread)
@@ -39,6 +66,29 @@ public class AccessibilityTreeModel
         xListener = new QueuedListener();   // asyncronous event delivery
     }
 
+    /** Lock the tree.  While the tree is locked, events from the outside are
+        not processed.  Lock the tree when you change its internal structure.
+    */
+    public void lock ()
+    {
+        mnLockCount += 1;
+    }
+
+    /** Unlock the tree.  After unlocking the tree as many times as locking
+        it, a treeStructureChange event is sent to the event listeners.
+        @param aNodeHint
+            If not null and treeStructureChange events are thrown then this
+            node is used as root of the modified subtree.
+    */
+    public void unlock (AccessibleTreeNode aNodeHint)
+    {
+        mnLockCount -= 1;
+        if (mnLockCount == 0)
+        {
+            if (aNodeHint instanceof AccTreeNode)
+                fireTreeStructureChanged (createEvent (((AccTreeNode)aNodeHint).getAccessible()));
+        }
+    }
 
     //
     // the root node
@@ -58,198 +108,150 @@ public class AccessibilityTreeModel
 
     public int getChildCount(Object aParent)
     {
-        return (aParent instanceof AccTreeNode) ?
-            ((AccTreeNode)aParent).getChildCount() : 0;
+        return (aParent instanceof AccessibleTreeNode) ?
+            ((AccessibleTreeNode)aParent).getChildCount() : 0;
     }
 
-    public Object getChild(Object aParent, int nIndex)
+    public Object getChild (Object aParent, int nIndex)
     {
-        Object aRet = (aParent instanceof AccTreeNode) ?
-            ((AccTreeNode)aParent).getChild(nIndex) : null;
-        setNode( aParent, nIndex, aRet );   // update tree cache
-        return aRet;
+        Object aChild = null;
+        try
+        {
+            if (aParent instanceof AccessibleTreeNode)
+                aChild = getChild ((AccessibleTreeNode)aParent, nIndex);
+            else
+                System.out.println ("getChild called for unknown parent node");
+        }
+        catch (com.sun.star.lang.IndexOutOfBoundsException e)
+        {
+            aChild = ("no child " + nIndex + " from " + aParent + ": " + e);
+        }
+        return aChild;
+    }
+
+    /** Delegate the request to the parent and then register listeners at
+        the child and add the child to the canvas.
+    */
+    public synchronized AccessibleTreeNode getChild (AccessibleTreeNode aParent, int nIndex)
+        throws com.sun.star.lang.IndexOutOfBoundsException
+    {
+        AccessibleTreeNode aChild = null;
+        if (aParent != null)
+            aChild = aParent.getChild(nIndex);
+        registerAccListener (aChild);
+
+        // Keep translation table up-to-date.
+        if (aChild != null)
+            if (aChild instanceof AccTreeNode)
+            {
+                maXAccessibleToNode.put (((AccTreeNode)aChild).getAccessible(), aChild);
+                addToCanvas ((AccTreeNode)aChild);
+            }
+        if (aChild == null)
+            System.out.println ("getChild: child not found");
+        return aChild;
     }
 
     /** iterate over all children and look for child */
-    public int getIndexOfChild(Object aParent, Object aChild)
+    public int getIndexOfChild (Object aParent, Object aChild)
     {
-        aChild = normalize( aChild );
+        int nIndex = -1;
+        try
+        {
+            if ((aParent instanceof AccessibleTreeNode) && (aChild instanceof AccessibleTreeNode))
+            {
+                AccessibleTreeNode aParentNode = (AccessibleTreeNode) aParent;
+                AccessibleTreeNode aChildNode = (AccessibleTreeNode) aChild;
 
-        // compare to all children
-        int nChildCount = getChildCount( aParent );
-        for( int i = 0; i < nChildCount; i++ )
+                int nChildCount = aParentNode.getChildCount();
+                for( int i = 0; i < nChildCount; i++ )
+                {
+                    if (aChildNode.equals (aParentNode.getChild (i)))
+                    {
+                        nIndex = i;
+                        break;
+                    }
+                }
+            }
+        }
+        catch (com.sun.star.lang.IndexOutOfBoundsException e)
         {
-            if( aChild.equals( normalize( getChild(aParent, i) ) ) )
-                return i;
+            // Return -1 by falling through.
         }
 
         // not found?
-        return -1;
+        return nIndex;
     }
 
 
-    public boolean isLeaf(Object aNode)
+    public boolean isLeaf (Object aNode)
     {
-        return (aNode instanceof AccTreeNode) ?
-            ((AccTreeNode)aNode).isLeaf() : true;
+        return (aNode instanceof AccessibleTreeNode) ?
+            ((AccessibleTreeNode)aNode).isLeaf() : true;
     }
 
 
-    //
-    // tree cache and child cache
-    //
-
-    /** store parents of an object in the tree; HashMap<Object> */
-    private HashMap aParents;
-
-    /** store a vector with the children in each tree;
-     *  HashMap<Vector<Object>> */
-    private HashMap aChildren;
 
-    /** store a mapping of 'normalized' nodes to nodes in the tree */
-    private HashMap aNodes;
-
-
-    /** normalize an object reference:
-     * 0) for an Any, get the containing Object
-     * 1) for AccTreeNode, get the data object
-     * 2) for XAccessible, get the accessible object
-     * 3) cast all UNO objects to XInterface
-     */
-    static protected Object normalize(Object aObject)
+    /** Remove a node (and all children) from the tree model.
+    */
+    protected synchronized void removeNode (AccessibleTreeNode aNode)
     {
-        // 0) for an Any, get the containing Object
-        if( aObject instanceof Any )
-            aObject = ((Any)aObject).getObject();
-
-        // 1) for AccTreeNode, get the data object
-        if( aObject instanceof AccTreeNode )
-            aObject = ((AccTreeNode)aObject).getDataObject();
-
-        if( aObject instanceof XInterface )
+        try
         {
-            // 2) for XAccessible, get the accessible object
-            XAccessible xAcc = (XAccessible)UnoRuntime.queryInterface(
-                                   XAccessible.class, aObject);
-            if( xAcc != null )
-                aObject = xAcc.getAccessibleContext();
-
-            // 3) cast all UNO objects to XInterface
-            aObject = (XInterface)UnoRuntime.queryInterface( XInterface.class,
-                                                             aObject);
-        }
-        return aObject;
-    }
-
-    /** add a parent/child int the node cache */
-    protected void setNode(Object aOParent, int nIndex, Object aOChild)
-    {
-        Object aParent = normalize(aOParent);
-        Object aChild = normalize(aOChild);
-
-        // store nodes
-        aNodes.put( aParent, aOParent );
-        aNodes.put( aChild, aOChild );
-
-        // store the child's parent
-        aParents.put( aChild, aParent );
+            if( aNode == null )
+                return;
+            removeAccListener (aNode);
+            removeFromCanvas (aNode);
+            if (aNode instanceof AccTreeNode)
+                maXAccessibleToNode.remove (((AccTreeNode)aNode).getAccessible());
+            AccessibleTreeNode aParent = aNode.getParent();
+            if (aParent != null)
+            {
+                int nIndex = aParent.indexOf(aNode);
+                aParent.removeChild (nIndex);
+            }
 
-        // store the parent's child
-        Vector aKids = (Vector)aChildren.get( aParent );
-        if( aKids == null )
+            // depth-first removal of children
+            while (aNode.getChildCount() > 0)
+                removeNode (aNode.getChild (0));
+        }
+        catch (com.sun.star.lang.IndexOutOfBoundsException e)
         {
-            // no children known... insert a new vector
-            aKids = new Vector();
-            aChildren.put( aParent, aKids );
+            // Ignore.
         }
-
-        // make sure we have enough room
-        if( aKids.size() <= nIndex )
-            aKids.setSize( nIndex + 1 ); // alternative: use child count
-
-        // add child at appropriate positions; remove old listeners,
-        // get new ones
-        removeAccListener( aKids.elementAt( nIndex ) );
-        aKids.setElementAt( aChild, nIndex );
-        registerAccListener( aKids.elementAt( nIndex ) );
-
-        // update canvas
-        addToCanvas( aChild );
     }
 
-    /** remove a node (and all children) from the node cache */
-    protected void removeNode(Object aNode)
+    protected synchronized boolean addNode (AccTreeNode aParentNode, XAccessible xNewChild)
     {
-        if( aNode == null )
-            return;
-
-        aNode = normalize( aNode );
-        removeAccListener( aNode );
-
-        // get parent + kids (before this information is deleted)
-        Vector aKids = (Vector)aChildren.get( aNode );
-        Object aParent = aParents.get( aNode );
-
-        // remove information about this node
-        removeFromCanvas( aNode );        // update canvas
-        aParents.remove( aNode );
-        aChildren.remove( aNode );
-        aNodes.remove( aNode );
+        boolean bRet = false;
 
-        // depth-first removal of children
-        int nLength = (aKids == null) ? 0 : aKids.size();
-        for( int i = nLength-1; i >= 0; i-- )
+        AccessibleTreeNode aChildNode = (AccessibleTreeNode)maXAccessibleToNode.get (xNewChild);
+        if (aChildNode == null)
         {
-            removeNode( aKids.elementAt(i) );
-        }
-
-        // remove from parents' child vector
-        if( aParent != null )
-        {
-            Vector aParentKids = (Vector)aChildren.get( aParent );
-            if( aParentKids != null )
-                aParentKids.remove( aNode );
+            AccTreeNode aChild = (AccTreeNode)((AccTreeNode)aParentNode).addAccessibleChild (xNewChild);
+            TreePath aPath = new TreePath (createPath (aChild));
+            if (aChild != null)
+            {
+                registerAccListener (aChild);
+                maXAccessibleToNode.put (aChild.getAccessible(), aChild);
+                addToCanvas (aChild);
+            }
+            bRet = true;
         }
-    }
+        else
+            System.out.println ("node already present");
 
-    /** determine whether this node is in the node cache */
-    protected boolean knowsNode(Object aNode)
-    {
-        // we never 'know' null; we 'know' a node if it has a parent
-        return (aNode != null) && (aNodes.get(normalize(aNode)) != null);
+        return bRet;
     }
 
-    protected Object getNode(Object aObject)
-    {
-        return aNodes.get( normalize(aObject) );
-    }
-
-    /** recursively traverse aParents, and add nodes to path in
-     * post-order fashion. This causes the root to be the first
-     * element, just as demanded by TreeModelEvent.
-     * @see javax.swing.event.TreeModelEvent#TreeModelEvent
-     */
-    private void createPath(Object aNode, Vector aPath)
-    {
-        aNode = normalize(aNode);
-        Object aParent = aParents.get(aNode);
-        if( aParent != null )
-            createPath( aParent, aPath );
-        Object aPathElem = aNodes.get(aNode);
-        if( aPathElem != null )
-            aPath.add( aPathElem );
-        else
-            System.out.println("Unknown node in path! (" + aNode +
-                               ", pos. " + aPath.size() + ")");
-    }
 
     /** create path to node, suitable for TreeModelEvent constructor
      * @see javax.swing.event.TreeModelEvent#TreeModelEvent
      */
-    protected Object[] createPath(Object aNode)
+    protected Object[] createPath (AccessibleTreeNode aNode)
     {
         Vector aPath = new Vector();
-        createPath( aNode, aPath );
+        aNode.createPath (aPath);
         return aPath.toArray();
     }
 
@@ -260,93 +262,88 @@ public class AccessibilityTreeModel
     // tree cache, and we should get removed as soon as they are out.
     //
 
-    Vector aListeners;
-
     public void addTreeModelListener(TreeModelListener l)
     {
-        aListeners.add(l);
+        maTMListeners.add(l);
     }
 
     public void removeTreeModelListener(TreeModelListener l)
     {
-        aListeners.remove(l);
+        maTMListeners.remove(l);
     }
 
     protected void fireTreeNodesChanged(TreeModelEvent e)
     {
         System.out.println("treeNodesChanges: " + e);
-        for(int i = 0; i < aListeners.size(); i++)
+        for(int i = 0; i < maTMListeners.size(); i++)
         {
-            ((TreeModelListener)aListeners.get(i)).treeNodesChanged(e);
+            ((TreeModelListener)maTMListeners.get(i)).treeNodesChanged(e);
         }
     }
 
     protected void fireTreeNodesInserted(final TreeModelEvent e)
     {
         System.out.println("treeNodesInserted: " + e);
-        for(int i = 0; i < aListeners.size(); i++)
+        for(int i = 0; i < maTMListeners.size(); i++)
         {
-            ((TreeModelListener)aListeners.get(i)).treeNodesInserted(e);
+            ((TreeModelListener)maTMListeners.get(i)).treeNodesInserted(e);
         }
     }
 
     protected void fireTreeNodesRemoved(final TreeModelEvent e)
     {
         System.out.println("treeNodesRemoved: " + e);
-        for(int i = 0; i < aListeners.size(); i++)
+        for(int i = 0; i < maTMListeners.size(); i++)
         {
-            ((TreeModelListener)aListeners.get(i)).treeNodesRemoved(e);
+            ((TreeModelListener)maTMListeners.get(i)).treeNodesRemoved(e);
         }
     }
 
-    protected void fireTreeStructureChanged(final TreeModelEvent e)
+    protected synchronized void fireTreeStructureChanged(final TreeModelEvent e)
     {
         System.out.println("treeStructureChanged: " + e);
-        for(int i = 0; i < aListeners.size(); i++)
+        for(int i = 0; i < maTMListeners.size(); i++)
         {
-            ((TreeModelListener)aListeners.get(i)).treeStructureChanged(e);
+            ((TreeModelListener)maTMListeners.get(i)).treeStructureChanged(e);
         }
     }
 
-    protected TreeModelEvent createEvent( Object aNode )
+    protected TreeModelEvent createEvent (XAccessible xParent)
     {
-        return createEvent( aNode, null );
+        return createEvent (xParent, null );
     }
 
-    protected TreeModelEvent createEvent( Object aParent, Object aChild )
+    /** Create a TreeModelEvent object that informs listeners that one child
+        has been removed from or inserted into its parent.
+    */
+    protected TreeModelEvent createEvent (XAccessible xParent, XAccessible xChild)
     {
         // get parent node and create the tree path
-        Object aParentNode = getNode( aParent );
-        Object[] aPath = createPath( aParentNode );
-
-        // if we already know the node (e.g. when deleting a node),
-        // use the position from the node cache. Else (e.g. when
-        // inserting a node), call getIndexOfChild to look for it.
-        int nIndex =-1;
-        if( aChild != null )
-        {
-            if( knowsNode( aChild ) )
-            {
-                Vector aKids = (Vector)aChildren.get( aParent );
-                if( aKids != null )
-                {
-                    nIndex = aKids.indexOf( getNode( aChild ) );
-                }
-            }
-            else
-                nIndex = getIndexOfChild( aParentNode, aChild );
-        }
-
-
-        // If we have a position, broadcast the position, otherwise
-        // create a 'position-less' event without the child info.
-        return ( nIndex == -1 )
-            ? new TreeModelEvent( this, aPath )
-                : new TreeModelEvent( this, aPath,
-                                      new int[] { nIndex },
-                                      new Object[] { getNode( aChild ) } );
+        AccessibleTreeNode aParentNode = (AccessibleTreeNode)maXAccessibleToNode.get (xParent);
+        Object[] aPathToParent = createPath (aParentNode);
+
+        AccessibleTreeNode aChildNode = null;
+        if (xChild != null)
+            aChildNode = (AccessibleTreeNode)maXAccessibleToNode.get (xChild);
+        int nIndexInParent = -1;
+        if (xChild != null)
+            nIndexInParent = aParentNode.indexOf (aChildNode);
+
+        System.out.println (aParentNode + " " + aChildNode);
+
+        if (nIndexInParent == -1)
+            // This event may be passed only to treeStructureChanged of the listeners.
+            return new TreeModelEvent (this,
+                aPathToParent);
+        else
+            // General purpose event for removing or inserting known nodes.
+            return new TreeModelEvent (this,
+                aPathToParent,
+                new int[] {nIndexInParent},
+                new Object[] {aChildNode} );
     }
 
+
     /**
      * broadcast a tree event in a seperate Thread
      * must override fire method
@@ -355,9 +352,9 @@ public class AccessibilityTreeModel
     {
         public void run()
         {
-            for(int i = 0; i < aListeners.size(); i++)
+            for(int i = 0; i < maTMListeners.size(); i++)
             {
-                fire( (TreeModelListener)aListeners.get(i) );
+                fire( (TreeModelListener)maTMListeners.get(i) );
             }
         }
 
@@ -375,7 +372,7 @@ public class AccessibilityTreeModel
     protected XAccessibleEventBroadcaster getBroadcaster( Object aObject )
     {
         if( aObject instanceof AccTreeNode )
-            aObject = ((AccTreeNode)aObject).getDataObject();
+            aObject = ((AccTreeNode)aObject).getContext();
         return (XAccessibleEventBroadcaster) UnoRuntime.queryInterface (
             XAccessibleEventBroadcaster.class, aObject);
     }
@@ -411,105 +408,78 @@ public class AccessibilityTreeModel
     // static methods + members for creating default nodes
     //
 
-    // default handlers, Vector<HandlerPair>
-    private static Vector aDefaultHandlers;
-
-    // initialize default handlers
-    static
-    {
-        aDefaultHandlers = new Vector();
-        aDefaultHandlers.add(
-            new HandlerPair( Vector.class,
-                             new VectorHandler() ) );
-
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleContext.class,
-                             new AccessibleContextHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleContext.class,
-                             new AccessibleTreeHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleText.class,
-                             new AccessibleTextHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleComponent.class,
-                             new AccessibleComponentHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleExtendedComponent.class,
-                             new AccessibleExtendedComponentHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleAction.class,
-                             new AccessibleActionHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleImage.class,
-                             new AccessibleImageHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleTable.class,
-                             new AccessibleTableHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleEditableText.class,
-                             new AccessibleEditableTextHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleHypertext.class,
-                             new AccessibleHypertextHandler() ) );
-        aDefaultHandlers.add(
-            new HandlerPair( XAccessibleHyperlink.class,
-                             new AccessibleHyperlinkHandler() ) );
-
-        // ... ADD NEW DEFAULT HANDLERS HERE ...
-
-    }
-
 
 
     /** add default handlers based on the supported interfaces */
-    public static void addDefaultHandlers( AccTreeNode aNode )
+    public static void addDefaultHandlers (AccTreeNode aNode, XAccessibleContext xContext)
     {
-        Object aObject = aNode.getDataObject();
-
-        // try each type
-        Enumeration aEnum = aDefaultHandlers.elements();
-        while( aEnum.hasMoreElements() )
+        if (false)
         {
-            HandlerPair aPair = (HandlerPair)aEnum.nextElement();
-            Class aType = aPair.aType;
+            // Slow but complete version: try each handler type separately.
+            aNode.addHandler (maContextHandler.createHandler (xContext));
+            aNode.addHandler (maTextHandler.createHandler (xContext));
+            aNode.addHandler (maEditableTextHandler.createHandler (xContext));
+            aNode.addHandler (maComponentHandler.createHandler (xContext));
+            aNode.addHandler (maExtendedComponentHandler.createHandler (xContext));
+            aNode.addHandler (maActionHandler.createHandler (xContext));
+            aNode.addHandler (maImageHandler.createHandler (xContext));
+            aNode.addHandler (maTableHandler.createHandler (xContext));
+            aNode.addHandler (maHypertextHandler.createHandler (xContext));
+            aNode.addHandler (maHyperlinkHandler.createHandler (xContext));
+            aNode.addHandler (maTreeHandler.createHandler (xContext));
+        }
+        else
+        {
+            // Exploit dependencies between interfaces.
+            NodeHandler aHandler;
+            aNode.addHandler (maContextHandler.createHandler (xContext));
 
-            // try instanceof, and a UNO query, if we have an XInterface
-            if( aType.isInstance( aObject ) )
+            aHandler = maTextHandler.createHandler (xContext);
+            if (aHandler != null)
             {
-                aNode.addHandler( aPair.aHandler );
+                aNode.addHandler (aHandler);
+                aNode.addHandler (maEditableTextHandler.createHandler (xContext));
+                aNode.addHandler (maHypertextHandler.createHandler (xContext));
+                aNode.addHandler (maHyperlinkHandler.createHandler (xContext));
             }
-            else if( XInterface.class.isAssignableFrom( aType ) )
+            aHandler = maComponentHandler.createHandler (xContext);
+            if (aHandler != null)
             {
-                Object aQuery = UnoRuntime.queryInterface(aType, aObject);
-                if( aQuery != null )
-                    aNode.addHandler( aPair.aHandler );
+                aNode.addHandler (aHandler);
+                aNode.addHandler (maExtendedComponentHandler.createHandler (xContext));
             }
+            aNode.addHandler (maActionHandler.createHandler (xContext));
+            aNode.addHandler (maImageHandler.createHandler (xContext));
+            aNode.addHandler (maTableHandler.createHandler (xContext));
+            aNode.addHandler (maTreeHandler.createHandler (xContext));
         }
     }
 
     /** create a node with the default handlers */
-    public static AccTreeNode createDefaultNode( Object aObject )
+    public static AccTreeNode createDefaultNode (XAccessible xAccessible, AccessibleTreeNode aParent)
     {
         // default: aObject + aDisplay
-        Object aDisplay = aObject;
+        String sDisplay;
 
         // if we are accessible, we use the context + name instead
-        XAccessible xAccessible =
-            (XAccessible) UnoRuntime.queryInterface (
-                XAccessible.class, aObject);
+        XAccessibleContext xContext = null;
         if (xAccessible != null)
-        {
-            XAccessibleContext aContext = xAccessible.getAccessibleContext();
+            xContext = xAccessible.getAccessibleContext();
+        if (xContext != null)
+            sDisplay = xContext.getAccessibleName();
+        else
+            sDisplay = new String ("not accessible");
 
-            // for accessibles, use context + name!
-            aObject = aContext;
-            aDisplay = aContext.getAccessibleName();
-        }
 
         // create node, and add default handlers
-        AccTreeNode aNode = new AccTreeNode( aObject, aDisplay );
-        AccessibilityTreeModel.addDefaultHandlers( aNode );
+        AccTreeNode aNode = new AccTreeNode (xContext, sDisplay, aParent);
+        AccessibilityTreeModel.addDefaultHandlers (aNode, xContext);
+
+        if (mbVerbose)
+            maPrinter.print (". ");
+
+        if (aNode == null)
+            System.out.println ("createDefaultNode == null");
         return aNode;
     }
 
@@ -537,7 +507,7 @@ public class AccessibilityTreeModel
 
     public void disposing( EventObject aEvent)
     {
-        System.out.println("dispose: " + objectToString(aEvent.Source));
+        /*        System.out.println("dispose: " + objectToString(aEvent.Source));
 
         if( knowsNode( aEvent.Source ) )
         {
@@ -546,7 +516,7 @@ public class AccessibilityTreeModel
             removeNode( aEvent.Source );
 //            fireTreeStructureChanged( createEvent( getRoot() ) );
         }
-
+        */
     }
 
     static final String[] aEventNames =
@@ -562,39 +532,74 @@ public class AccessibilityTreeModel
         "[UNKNOWN]"
     };
 
-    public void notifyEvent( AccessibleEventObject aEvent )
+    /** This method is called from accessible objects that broadcast
+        modifications of themselves or from their children.  The event is
+        processed only, except printing some messages, if the tree is not
+        locked.  It should be locked during changes to its internal
+        structure like expanding nodes.
+    */
+    public synchronized void notifyEvent( AccessibleEventObject aEvent )
     {
 
         int nId = aEvent.EventId;
         if( (nId < 0) || (nId >= aEventNames.length) )
             nId = 0;
 
-        Object aSource = normalize( aEvent.Source );
-        Object aOld = normalize( aEvent.OldValue );
-        Object aNew = normalize( aEvent.NewValue );
+        System.out.println( "notify: " + aEvent.EventId + " "
+            + aEventNames[nId] + ": "
+            + objectToString(aEvent.Source) + " "
+            + objectToString(aEvent.OldValue) + "->"
+            + objectToString(aEvent.NewValue) );
 
-        System.out.println( "notify: " + aEvent.EventId + " " +
-                            aEventNames[nId] + ": " +
-                            objectToString(aEvent.Source) + " (" +
-                            (knowsNode(aEvent.Source) ? "known" : "unknown") +
-                            "), " +
-                            objectToString(aEvent.OldValue) + "->" +
-                            objectToString(aEvent.NewValue) );
+        if (mnLockCount > 0)
+        {
+            System.out.println ("ignoring event because tree is locked");
+            return;
+        }
 
+        XAccessible xSource = (XAccessible)UnoRuntime.queryInterface(
+            XAccessible.class,aEvent.Source);
 
         switch( aEvent.EventId )
         {
             case AccessibleEventId.ACCESSIBLE_CHILD_EVENT:
                 // fire insertion and deletion events:
-                if( aOld != null )
+                if (aEvent.OldValue != null)
                 {
-                    TreeModelEvent aTreeEvent = createEvent( aSource, aOld );
-                    removeNode( aOld );
-                    fireTreeNodesRemoved( aTreeEvent );
+                    XAccessible xOld = (XAccessible)UnoRuntime.queryInterface(
+                        XAccessible.class,aEvent.OldValue);
+                    // Create event before removing the node to get the old
+                    // index of the node.
+                    TreeModelEvent aRemoveEvent = createEvent (xSource, xOld);
+                    removeNode ((AccessibleTreeNode)maXAccessibleToNode.get (xOld));
+                    fireTreeNodesRemoved (aRemoveEvent);
                 }
-                if( aNew != null )
+                // Insertion and removal of children should be mutually
+                // exclusive.  But then there is this 'should' ...
+                if (aEvent.NewValue != null)
                 {
-                    fireTreeNodesInserted( createEvent( aSource, aNew ) );
+                    XAccessible xNew = (XAccessible)UnoRuntime.queryInterface(
+                        XAccessible.class,aEvent.NewValue);
+                    // Create event after inserting it so that its new index
+                    // in the parent can be determined.
+                    AccessibleTreeNode aParentNode = (AccessibleTreeNode)maXAccessibleToNode.get (xSource);
+                    if (aParentNode instanceof AccTreeNode)
+                    {
+                        if (addNode ((AccTreeNode)aParentNode, xNew))
+                        {
+                            ((AccTreeNode)aParentNode).update ();
+                            updateOnCanvas (xSource);
+
+                            // A call to fireTreeNodesInserted for xNew
+                            // should be sufficient but at least the
+                            // StringNode object that contains the number of
+                            // children also changes and we do not know its
+                            // index relative to its parent.  Therefore the
+                            // more expensive fireTreeStructureChanged is
+                            // necessary.
+                            fireTreeStructureChanged (createEvent (xSource));
+                        }
+                    }
                 }
                 break;
             case AccessibleEventId.ACCESSIBLE_TABLE_MODEL_CHANGED:
@@ -628,8 +633,13 @@ public class AccessibilityTreeModel
             case AccessibleEventId.LABEL_FOR_PROPERTY:
             case AccessibleEventId.LABELED_BY_PROPERTY:
             case AccessibleEventId.MEMBER_OF_PROPERTY:
-                fireTreeNodesChanged( createEvent( aSource ) );
-                updateOnCanvas( aSource );
+                //                fireTreeNodesChanged (createEvent
+                //                (xSource));
+                // Some child(s) of xSource have changed.  We do not know
+                // which so all we can do is send a structure change event
+                // to all listeners.
+                fireTreeStructureChanged (createEvent (xSource));
+                updateOnCanvas (xSource);
                 break;
 
 
@@ -660,13 +670,15 @@ public class AccessibilityTreeModel
         return xAcc;
     }
 
-    protected void addToCanvas( Object aObject )
+    protected void addToCanvas (AccTreeNode aNode)
     {
-        XAccessibleContext xContext = getContext( aObject );
-        if( (maCanvas != null) && (xContext != null) )
-            maCanvas.addContext( xContext,
-                                 new TreePath( createPath( xContext ) ) );
-    }
+        return;
+        /*        XAccessibleContext xContext = aNode.getContext();
+        if ((maCanvas != null) && (xContext != null))
+            maCanvas.addContext (
+                xContext,
+                new TreePath (createPath (aNode)));
+        */    }
 
     protected void removeFromCanvas( Object aObject )
     {
diff --git a/toolkit/test/accessibility/AccessibilityWorkBench.java b/toolkit/test/accessibility/AccessibilityWorkBench.java
index 8021e12f5d09..7814e146ce9b 100755
--- a/toolkit/test/accessibility/AccessibilityWorkBench.java
+++ b/toolkit/test/accessibility/AccessibilityWorkBench.java
@@ -179,7 +179,7 @@ public class AccessibilityWorkBench
         maMainPanel.add (aScrollPane);
 
         //  Accessible Tree.
-        maTree = new AccessibilityTree (this, maCanvas);
+        maTree = new AccessibilityTree (this, maCanvas, this);
         aScrollPane = new JScrollPane(maTree,
             JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
             JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
@@ -212,8 +212,8 @@ public class AccessibilityWorkBench
         aConnectButton = createButton ("Connect", "connect");
         aLoadButton = createButton ("Load", "load");
         aUpdateButton = createButton ("Update", "update");
-        aShapesButton = createButton ("Shapes", "shapes");
-        aExpandButton = createButton ("Expand", "expand");
+        aShapesButton = createButton ("Expand Shapes", "shapes");
+        aExpandButton = createButton ("Expand All", "expand");
         aTextButton = createButton("Text", "text");
         aQuitButton = createButton ("Quit", "quit");
 
@@ -232,6 +232,7 @@ public class AccessibilityWorkBench
     public JButton createButton (String title, String command)
     {
         JButton aButton = new JButton (title);
+        aButton.setEnabled (false);
         aButton.setActionCommand (command);
         aButton.addActionListener (this);
         GridBagConstraints constraints = new GridBagConstraints ();
@@ -253,10 +254,18 @@ public class AccessibilityWorkBench
 
         // create new model (with new documents)
         AccessibilityTreeModel aModel =
-            new AccessibilityTreeModel( createTreeModelRoot() );
+            new AccessibilityTreeModel (createTreeModelRoot(), this, this);
         aModel.setCanvas( maCanvas );
         maTree.setModel( aModel );
 
+        aConnectButton.setEnabled (true);
+        aQuitButton.setEnabled (true);
+        aLoadButton.setEnabled (true);
+        aUpdateButton.setEnabled (true);
+        aExpandButton.setEnabled (true);
+        aShapesButton.setEnabled (true);
+        aTextButton.setEnabled (true);
+
         //        if (office != null && office.getDesktop() != null)
         //  office.getDesktop().addTerminateListener (this);
     }
@@ -293,15 +302,22 @@ public class AccessibilityWorkBench
         }
         else if (e.getActionCommand().equals("shapes"))
         {
+            Cursor aCursor = getCursor();
+            setCursor (new Cursor (Cursor.WAIT_CURSOR));
             maTree.expandShapes();
+            setCursor (aCursor);
         }
         else if (e.getActionCommand().equals("expand"))
         {
+            Cursor aCursor = getCursor();
+            setCursor (new Cursor (Cursor.WAIT_CURSOR));
             maTree.expandAll();
+            setCursor (aCursor);
         }
         else if (e.getActionCommand().equals("text"))
         {
             Canvas.bPaintText = ! Canvas.bPaintText;
+            maCanvas.repaint ();
         }
         else
         {
@@ -315,8 +331,8 @@ public class AccessibilityWorkBench
     /** Create an AccessibilityTreeModel root which contains the documents */
     private Object createTreeModelRoot()
     {
-        Vector aRoots = new Vector();
-
+        // create root node
+        VectorNode aRoot = new VectorNode ("Accessibility Tree", null);
         try
         {
             XDesktop xDesktop = office.getDesktop();
@@ -344,11 +360,9 @@ public class AccessibilityWorkBench
                     XAccessible xRoot = office.getAccessibleRoot (xWindow);
 
                     // create document node
-                    aRoots.add(
-                        AccessibilityTreeModel.createDefaultNode(xRoot) );
+                    aRoot.addChild (
+                        AccessibilityTreeModel.createDefaultNode (xRoot, aRoot));
                 }
-                else
-                    aRoots.add( "can't cast component to model" );
             }
             println ("finished getting named documents");
         }
@@ -357,10 +371,7 @@ public class AccessibilityWorkBench
             System.out.println ("caught exception while getting document names: " + e);
         }
 
-        // create root node
-        AccTreeNode aNode = new AccTreeNode( aRoots, "Accessibility Tree" );
-        AccessibilityTreeModel.addDefaultHandlers( aNode );
-        return aNode;
+        return aRoot;
     }
 
 
@@ -517,6 +528,7 @@ public class AccessibilityWorkBench
     public  void print (String text)
     {
         maOutputArea.append (text);
+        maOutputArea.paintImmediately (maOutputArea.getVisibleRect());
     }
 
 
@@ -527,6 +539,7 @@ public class AccessibilityWorkBench
         maOutputArea.append (text + "\n");
         JScrollBar aBar = maScrollPane.getVerticalScrollBar();
         aBar.setValue (aBar.getMaximum());
+        maOutputArea.paintImmediately (maOutputArea.getVisibleRect());
     }
 
 
diff --git a/toolkit/test/accessibility/AccessibleActionHandler.java b/toolkit/test/accessibility/AccessibleActionHandler.java
index e0c5b6cbb56a..ba9cd2793d00 100644
--- a/toolkit/test/accessibility/AccessibleActionHandler.java
+++ b/toolkit/test/accessibility/AccessibleActionHandler.java
@@ -1,45 +1,68 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleAction;
 import com.sun.star.lang.IndexOutOfBoundsException;
 
-class AccessibleActionHandler extends NodeHandler
+class AccessibleActionHandler
+    extends NodeHandler
 {
-    protected XAccessibleAction getAction(Object aObject)
+    public NodeHandler createHandler (XAccessibleContext xContext)
     {
-        return (XAccessibleAction) UnoRuntime.queryInterface (
-            XAccessibleAction.class, aObject);
+        XAccessibleAction xEComponent =
+            (XAccessibleAction) UnoRuntime.queryInterface (
+                XAccessibleAction.class, xContext);
+        if (xEComponent != null)
+            return new AccessibleActionHandler (xEComponent);
+        else
+            return null;
+    }
+
+    public AccessibleActionHandler ()
+    {
+    }
+
+    public AccessibleActionHandler (XAccessibleAction xAction)
+    {
+        if (xAction != null)
+            maChildList.setSize (1 + xAction.getAccessibleActionCount());
     }
 
-    public int getChildCount(Object aObject)
+    protected static XAccessibleAction getAction (AccTreeNode aParent)
     {
-        XAccessibleAction xAction = getAction(aObject);
-        return (xAction == null) ? 0 : 1 + xAction.getAccessibleActionCount();
+        return (XAccessibleAction) UnoRuntime.queryInterface (
+            XAccessibleAction.class, aParent.getContext());
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
     {
-        Object aRet = null;
+        AccessibleTreeNode aChild = null;
 
-        XAccessibleAction xAction = getAction(aObject);
-        if( xAction != null )
+        if (aParent instanceof AccTreeNode)
         {
-            if( nIndex == 1 )
-                aRet = "Actions: " + xAction.getAccessibleActionCount();
-            else
+            XAccessibleAction xAction = getAction ((AccTreeNode)aParent);
+            if( xAction != null )
             {
-                try
-                {
-                    aRet = "Action " + (nIndex-1) + " : " +
-                        xAction.getAccessibleActionDescription(nIndex-1);
-                }
-                catch( IndexOutOfBoundsException e )
+                if (nIndex == 0)
+                    aChild = new StringNode ("Number of actions: " + xAction.getAccessibleActionCount(),
+                        aParent);
+                else
                 {
-                    aRet = "ERROR";
+                    nIndex -= 1;
+                    try
+                    {
+                        aChild = new StringNode ("Action " + nIndex + " : "
+                            + xAction.getAccessibleActionDescription (nIndex),
+                            aParent);
+                    }
+                    catch( IndexOutOfBoundsException e )
+                    {
+                        aChild = new StringNode ("ERROR", aParent);
+                    }
                 }
             }
         }
 
-        return aRet;
+        return aChild;
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleComponentHandler.java b/toolkit/test/accessibility/AccessibleComponentHandler.java
index 699043ddacd9..51031533170c 100644
--- a/toolkit/test/accessibility/AccessibleComponentHandler.java
+++ b/toolkit/test/accessibility/AccessibleComponentHandler.java
@@ -1,45 +1,69 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleComponent;
 
 
-class AccessibleComponentHandler extends AccessibleTreeHandler
+class AccessibleComponentHandler
+    extends NodeHandler
 {
-    private XAccessibleComponent getComponent(Object aObject)
+
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        XAccessibleComponent xComponent = getComponent (xContext);
+        if (xComponent != null)
+            return new AccessibleComponentHandler (xComponent);
+        else
+            return null;
+
+    }
+
+    public AccessibleComponentHandler ()
     {
-        return (XAccessibleComponent) UnoRuntime.queryInterface (
-            XAccessibleComponent.class, aObject);
     }
 
-    public int getChildCount(Object aObject)
+    public AccessibleComponentHandler (XAccessibleComponent xComponent)
     {
-        return (getComponent(aObject) == null) ? 0 : 3;
+        if (xComponent != null)
+            maChildList.setSize (3);
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    private static XAccessibleComponent getComponent(Object aObject)
     {
-        XAccessibleComponent xComponent = getComponent(aObject);
+        return (XAccessibleComponent) UnoRuntime.queryInterface (
+            XAccessibleComponent.class, aObject);
+    }
 
-        Object aRet = null;
-        if( xComponent != null )
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
+    {
+        AccessibleTreeNode aChild = null;
+        if (aParent instanceof AccTreeNode)
         {
-            switch( nIndex )
+            XAccessibleComponent xComponent = getComponent (
+                ((AccTreeNode)aParent).getContext());
+
+            if (xComponent != null)
             {
-                case 0:
-                    aRet = "Location: "+ xComponent.getLocation().X +
-                        ", " + xComponent.getLocation().Y;
-                    break;
-                case 1:
-                    aRet = "Location on Screen: "+
-                        xComponent.getLocationOnScreen().X + ", " +
-                        xComponent.getLocationOnScreen().Y;
-                    break;
-                case 2:
-                    aRet =  "Size: "+ xComponent.getSize().Width + ", " +
-                        xComponent.getSize().Height;
-                    break;
+                switch (nIndex)
+                {
+                    case 0:
+                        aChild = new StringNode ("Location: "+ xComponent.getLocation().X +
+                            ", " + xComponent.getLocation().Y, aParent);
+                        break;
+                    case 1:
+                        aChild = new StringNode ("Location on Screen: "
+                            + xComponent.getLocationOnScreen().X + ", "
+                            + xComponent.getLocationOnScreen().Y,
+                            aParent);
+                        break;
+                    case 2:
+                        aChild = new StringNode ("Size: "+ xComponent.getSize().Width + ", "
+                            + xComponent.getSize().Height,
+                            aParent);
+                        break;
+                }
             }
         }
-        return aRet;
+        return aChild;
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleContextHandler.java b/toolkit/test/accessibility/AccessibleContextHandler.java
index 1e7ae3c0fae8..521a3f47d5fb 100644
--- a/toolkit/test/accessibility/AccessibleContextHandler.java
+++ b/toolkit/test/accessibility/AccessibleContextHandler.java
@@ -1,39 +1,60 @@
-
+import drafts.com.sun.star.accessibility.XAccessible;
 import drafts.com.sun.star.accessibility.XAccessibleContext;
+import com.sun.star.uno.UnoRuntime;
 
 
-class AccessibleContextHandler extends AccessibleTreeHandler
+class AccessibleContextHandler
+    extends NodeHandler
 {
-    public int getChildCount(Object aObject)
+    protected int nChildrenCount;
+
+    public NodeHandler createHandler (XAccessibleContext xContext)
     {
-        return (getContext(aObject) == null) ? 0 : 4;
+        if (xContext != null)
+            return new AccessibleContextHandler (xContext);
+        else
+            return null;
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleContextHandler ()
     {
-        XAccessibleContext xContext = getContext(aObject);
+        super ();
+    }
 
-        Object aRet = null;
-        if( xContext != null )
+    public AccessibleContextHandler (XAccessibleContext xContext)
+    {
+        super();
+        if (xContext != null)
+            maChildList.setSize (3);
+    }
+
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
+    {
+        XAccessibleContext xContext = null;
+        if (aParent instanceof AccTreeNode)
+            xContext = ((AccTreeNode)aParent).getContext();
+
+        String sChild = new String();
+        if (xContext != null)
         {
             switch( nIndex )
             {
                 case 0:
-                    aRet = "Description: " +
+                    sChild = "Description: " +
                         xContext.getAccessibleDescription();
                     break;
                 case 1:
-                    aRet = "Role: " + xContext.getAccessibleRole();
+                    sChild = "Role: " + xContext.getAccessibleRole();
                     break;
                 case 2:
-                    aRet = "Has parent: " +
+                    sChild = "Has parent: " +
                         (xContext.getAccessibleParent()!=null ? "yes" : "no");
                     break;
-                case 3:
-                    aRet = "Child count: " + xContext.getAccessibleChildCount();
-                    break;
+                    /*                case 3:
+                    sChild = "Child count: " + xContext.getAccessibleChildCount();
+                    break;*/
             }
         }
-        return aRet;
+        return new StringNode (sChild, aParent);
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleEditableTextHandler.java b/toolkit/test/accessibility/AccessibleEditableTextHandler.java
index 918f6bb2d787..c1c571435219 100644
--- a/toolkit/test/accessibility/AccessibleEditableTextHandler.java
+++ b/toolkit/test/accessibility/AccessibleEditableTextHandler.java
@@ -1,24 +1,40 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleEditableText;
 
 
 class AccessibleEditableTextHandler extends NodeHandler
 {
-    protected XAccessibleEditableText getEText(Object aObject)
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        XAccessibleEditableText xText =
+            (XAccessibleEditableText) UnoRuntime.queryInterface (
+                XAccessibleEditableText.class, xContext);
+        if (xText != null)
+            return new AccessibleEditableTextHandler (xText);
+        else
+            return null;
+    }
+
+    public AccessibleEditableTextHandler ()
     {
-        return (XAccessibleEditableText) UnoRuntime.queryInterface (
-            XAccessibleEditableText.class, aObject);
     }
 
-    public int getChildCount(Object aObject)
+    public AccessibleEditableTextHandler (XAccessibleEditableText xText)
     {
-        return (getEText(aObject) == null) ? 0 : 1;
+        if (xText != null)
+            maChildList.setSize (1);
+    }
+
+    protected static XAccessibleEditableText getEText (AccTreeNode aNode)
+    {
+        return (XAccessibleEditableText) UnoRuntime.queryInterface (
+            XAccessibleEditableText.class, aNode.getContext());
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
     {
-        XAccessibleEditableText xContext = getEText(aObject);
-        return "XAccessibleEditableText is supported";
+        return new StringNode ("XAccessibleEditableText is supported", aParent);
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleExtendedComponentHandler.java b/toolkit/test/accessibility/AccessibleExtendedComponentHandler.java
index 17e66d8353b3..1fb2d4518256 100644
--- a/toolkit/test/accessibility/AccessibleExtendedComponentHandler.java
+++ b/toolkit/test/accessibility/AccessibleExtendedComponentHandler.java
@@ -1,48 +1,71 @@
-
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleExtendedComponent;
 
 
-class AccessibleExtendedComponentHandler extends AccessibleTreeHandler
+class AccessibleExtendedComponentHandler
+    extends NodeHandler
 {
-    private XAccessibleExtendedComponent getComponent(Object aObject)
+    public NodeHandler createHandler (XAccessibleContext xContext)
     {
-        return (XAccessibleExtendedComponent) UnoRuntime.queryInterface (
-            XAccessibleExtendedComponent.class, aObject);
+        XAccessibleExtendedComponent xEComponent =
+            (XAccessibleExtendedComponent) UnoRuntime.queryInterface (
+                XAccessibleExtendedComponent.class, xContext);
+        if (xEComponent != null)
+            return new AccessibleExtendedComponentHandler (xEComponent);
+        else
+            return null;
     }
 
+    public AccessibleExtendedComponentHandler ()
+    {
+    }
 
-    public int getChildCount(Object aObject)
+    public AccessibleExtendedComponentHandler (XAccessibleExtendedComponent xEComponent)
     {
-        return (getComponent(aObject) == null) ? 0 : 2;
+        if (xEComponent != null)
+            maChildList.setSize (2);
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    private static XAccessibleExtendedComponent getComponent (AccTreeNode aNode)
     {
-        XAccessibleExtendedComponent xEComponent = getComponent(aObject);
+        return (XAccessibleExtendedComponent) UnoRuntime.queryInterface (
+            XAccessibleExtendedComponent.class,
+            aNode.getContext());
+    }
+
 
-        Object aRet = null;
-        if( xEComponent != null )
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
+    {
+        AccessibleTreeNode aChild = null;
+        if (aParent instanceof AccTreeNode)
         {
-            int nColor;
-            switch( nIndex )
+            XAccessibleExtendedComponent xEComponent = getComponent ((AccTreeNode)aParent);
+
+            if (xEComponent != null)
             {
-                case 0:
-                    nColor = xEComponent.getForeground();
-                    aRet = "Foreground color: R"
-                        +       (nColor>>16&0xff)
-                        + "G" + (nColor>>8&0xff)
-                        + "B" + (nColor>>0&0xff);
-                    break;
-                case 1:
-                    nColor = xEComponent.getBackground();
-                    aRet = "Background color: R"
-                        +       (nColor>>16&0xff)
-                        + "G" + (nColor>>8&0xff)
-                        + "B" + (nColor>>0&0xff);
-                    break;
+                int nColor;
+                switch( nIndex )
+                {
+                    case 0:
+                        nColor = xEComponent.getForeground();
+                        aChild = new StringNode ("Foreground color: R"
+                            +       (nColor>>16&0xff)
+                            + "G" + (nColor>>8&0xff)
+                            + "B" + (nColor>>0&0xff),
+                            aParent);
+                        break;
+                    case 1:
+                        nColor = xEComponent.getBackground();
+                        aChild = new StringNode ("Background color: R"
+                            +       (nColor>>16&0xff)
+                            + "G" + (nColor>>8&0xff)
+                            + "B" + (nColor>>0&0xff),
+                            aParent);
+                        break;
+                }
             }
         }
-        return aRet;
+        return aChild;
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleHyperlinkHandler.java b/toolkit/test/accessibility/AccessibleHyperlinkHandler.java
index a7bd0583d101..cc7381b78fa3 100644
--- a/toolkit/test/accessibility/AccessibleHyperlinkHandler.java
+++ b/toolkit/test/accessibility/AccessibleHyperlinkHandler.java
@@ -1,10 +1,32 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleHyperlink;
 
 
 class AccessibleHyperlinkHandler extends AccessibleTreeHandler
 {
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        XAccessibleHyperlink xLink =
+            (XAccessibleHyperlink) UnoRuntime.queryInterface (
+                XAccessibleHyperlink.class, xContext);
+        if (xLink != null)
+            return new AccessibleHyperlinkHandler (xLink);
+        else
+            return null;
+    }
+
+    public AccessibleHyperlinkHandler ()
+    {
+    }
+
+    public AccessibleHyperlinkHandler (XAccessibleHyperlink xLink)
+    {
+        if (xLink != null)
+            maChildList.setSize (1);
+    }
+
     protected XAccessibleHyperlink getHyperlink(Object aObject)
     {
         XAccessibleHyperlink xHyperlink =
@@ -13,13 +35,8 @@ class AccessibleHyperlinkHandler extends AccessibleTreeHandler
         return xHyperlink;
     }
 
-    public int getChildCount(Object aObject)
-    {
-        return (getHyperlink(aObject) == null) ? 0 : 1;
-    }
-
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode getChild (AccessibleTreeNode aParent, int nIndex)
     {
-        return "interface XAccessibleHyperlink is supported";
+        return new StringNode ("interface XAccessibleHyperlink is supported", aParent);
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleHypertextHandler.java b/toolkit/test/accessibility/AccessibleHypertextHandler.java
index 0e1f4ece6823..1742ed3a8d9d 100644
--- a/toolkit/test/accessibility/AccessibleHypertextHandler.java
+++ b/toolkit/test/accessibility/AccessibleHypertextHandler.java
@@ -1,25 +1,42 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleHypertext;
 
 
 class AccessibleHypertextHandler extends AccessibleTreeHandler
 {
-    protected XAccessibleHypertext getHypertext(Object aObject)
+    public NodeHandler createHandler (XAccessibleContext xContext)
     {
-        XAccessibleHypertext xHypertext =
+        XAccessibleHypertext xText =
             (XAccessibleHypertext) UnoRuntime.queryInterface (
-                 XAccessibleHypertext.class, aObject);
-        return xHypertext;
+                XAccessibleHypertext.class, xContext);
+        if (xText != null)
+            return new AccessibleHypertextHandler (xText);
+        else
+            return null;
+    }
+
+    public AccessibleHypertextHandler ()
+    {
     }
 
-    public int getChildCount(Object aObject)
+    public AccessibleHypertextHandler (XAccessibleHypertext xText)
     {
-        return (getHypertext(aObject) == null) ? 0 : 1;
+        if (xText != null)
+            maChildList.setSize (1);
+    }
+
+    protected static XAccessibleHypertext getHypertext (AccTreeNode aNode)
+    {
+        XAccessibleHypertext xHypertext =
+            (XAccessibleHypertext) UnoRuntime.queryInterface (
+                 XAccessibleHypertext.class, aNode.getContext());
+        return xHypertext;
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode getChild (AccessibleTreeNode aParent, int nIndex)
     {
-        return "interface XAccessibleHypertext is supported";
+        return new StringNode ("interface XAccessibleHypertext is supported", aParent);
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleImageHandler.java b/toolkit/test/accessibility/AccessibleImageHandler.java
index 260207699383..de924c00facf 100644
--- a/toolkit/test/accessibility/AccessibleImageHandler.java
+++ b/toolkit/test/accessibility/AccessibleImageHandler.java
@@ -1,25 +1,48 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleImage;
 
 
 class AccessibleImageHandler extends NodeHandler
 {
-    protected XAccessibleImage getImage(Object aObject)
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        XAccessibleImage xImage =
+            (XAccessibleImage) UnoRuntime.queryInterface (
+                XAccessibleImage.class, xContext);
+        if (xImage != null)
+            return new AccessibleImageHandler (xImage);
+        else
+            return null;
+    }
+
+    public AccessibleImageHandler ()
     {
-        return (XAccessibleImage) UnoRuntime.queryInterface (
-            XAccessibleImage.class, aObject);
     }
 
-    public int getChildCount(Object aObject)
+    public AccessibleImageHandler (XAccessibleImage xImage)
     {
-        return (getImage(aObject) == null) ? 0 : 1;
+        if (xImage != null)
+            maChildList.setSize (1);
+    }
+
+    protected static XAccessibleImage getImage (AccTreeNode aNode)
+    {
+        return (XAccessibleImage) UnoRuntime.queryInterface (
+            XAccessibleImage.class, aNode.getContext());
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
     {
-        XAccessibleImage xImage = getImage(aObject);
-        return (xImage == null) ? "" :
-            "Image description: " + xImage.getAccessibleImageDescription();
+        if (aParent instanceof AccTreeNode)
+        {
+            XAccessibleImage xImage = getImage ((AccTreeNode)aParent);
+            if (xImage != null)
+                return new StringNode (
+                    "Image description: " + xImage.getAccessibleImageDescription(),
+                    aParent);
+        }
+        return null;
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleTableHandler.java b/toolkit/test/accessibility/AccessibleTableHandler.java
index 90d6d1b791fd..8d281f83b786 100644
--- a/toolkit/test/accessibility/AccessibleTableHandler.java
+++ b/toolkit/test/accessibility/AccessibleTableHandler.java
@@ -1,24 +1,40 @@
 
 import com.sun.star.uno.UnoRuntime;
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleTable;
 
 
 class AccessibleTableHandler extends NodeHandler
 {
-    protected XAccessibleTable getTable(Object aObject)
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        XAccessibleTable xTable =
+            (XAccessibleTable) UnoRuntime.queryInterface (
+                XAccessibleTable.class, xContext);
+        if (xTable != null)
+            return new AccessibleTableHandler (xTable);
+        else
+            return null;
+    }
+
+    public AccessibleTableHandler ()
     {
-        return (XAccessibleTable) UnoRuntime.queryInterface (
-            XAccessibleTable.class, aObject);
     }
 
-    public int getChildCount(Object aObject)
+    public AccessibleTableHandler (XAccessibleTable xTable)
     {
-        return (getTable(aObject) == null) ? 0 : 1;
+        if (xTable != null)
+            maChildList.setSize (1);
+    }
+
+    protected static XAccessibleTable getTable(Object aObject)
+    {
+        return (XAccessibleTable) UnoRuntime.queryInterface (
+            XAccessibleTable.class, aObject);
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
     {
-        XAccessibleTable xTable = getTable(aObject);
-        return "interface XAccessibleTable is supported";
+        return new StringNode ("interface XAccessibleTable is supported", aParent);
     }
 }
diff --git a/toolkit/test/accessibility/AccessibleTextHandler.java b/toolkit/test/accessibility/AccessibleTextHandler.java
index a39cd69c9d86..5eb86b5213bb 100644
--- a/toolkit/test/accessibility/AccessibleTextHandler.java
+++ b/toolkit/test/accessibility/AccessibleTextHandler.java
@@ -1,4 +1,5 @@
 
+import drafts.com.sun.star.accessibility.XAccessibleContext;
 import drafts.com.sun.star.accessibility.XAccessibleText;
 import drafts.com.sun.star.accessibility.XAccessibleEditableText;
 import drafts.com.sun.star.accessibility.AccessibleTextType;
@@ -25,12 +26,32 @@ import javax.swing.text.JTextComponent;
 
 class AccessibleTextHandler extends NodeHandler
 {
+    private XAccessibleText mxText;
+
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        XAccessibleText xText = (XAccessibleText) UnoRuntime.queryInterface (
+            XAccessibleText.class, xContext);
+        if (xText != null)
+            return new AccessibleTextHandler (xText);
+        else
+            return null;
+    }
+
+    public AccessibleTextHandler ()
+    {
+    }
+
+    public AccessibleTextHandler (XAccessibleText xText)
+    {
+        mxText = xText;
+        if (mxText != null)
+            maChildList.setSize (12);
+    }
+
     protected XAccessibleText getText( Object aObject )
     {
-        XAccessibleText xText =
-            (XAccessibleText) UnoRuntime.queryInterface (
-                 XAccessibleText.class, aObject);
-        return xText;
+        return mxText;
     }
 
     protected XAccessibleEditableText getEditText( Object aObject )
@@ -43,67 +64,82 @@ class AccessibleTextHandler extends NodeHandler
 
 
 
-    public int getChildCount(Object aObject)
-    {
-        return (getText(aObject) != null) ? 12 : 0;
-    }
-
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
     {
-        Object aRet = null;
+        AccessibleTreeNode aChild = null;
+        XAccessibleText xText = null;
+        if (aParent instanceof AccTreeNode)
+            xText = getText (((AccTreeNode)aParent).getContext());
 
-        XAccessibleText xText = getText( aObject );
-        if( xText != null )
+        try
         {
-            switch( nIndex )
+            if( xText != null )
             {
-                case 0:
-                    aRet = xText.getText();
-                    break;
-                case 1:
-                    aRet = "# chars: " + xText.getCharacterCount();
-                    break;
-                case 2:
-                    aRet = characters( xText );
-                    break;
-                case 3:
-                    aRet = "selection: " + "[" + xText.getSelectionStart() +
-                        "," + xText.getSelectionEnd() + "] \"" +
-                        xText.getSelectedText() + "\"";
-                    break;
-                case 4:
-                    aRet = "getCaretPosition: " + xText.getCaretPosition();
-                    break;
-                case 5:
-                    aRet = textAtIndexNode( xText, "Character",
-                                            AccessibleTextType.CHARACTER );
-                    break;
-                case 6:
-                    aRet = textAtIndexNode( xText, "Word",
-                                            AccessibleTextType.WORD );
-                    break;
-                case 7:
-                    aRet = textAtIndexNode( xText, "Sentence",
-                                            AccessibleTextType.SENTENCE );
-                    break;
-                case 8:
-                    aRet = textAtIndexNode( xText, "Paragraph",
-                                            AccessibleTextType.PARAGRAPH );
-                    break;
-                case 9:
-                    aRet = textAtIndexNode( xText, "Line",
-                                            AccessibleTextType.LINE );
-                    break;
-                case 10:
-                    aRet = textAtIndexNode( xText, "Attribute",
-                                            (short)6/*AccessibleTextType.ATTRIBUTE*/);
-                    break;
-                case 11:
-                    aRet = bounds( xText );
-                    break;
+                switch( nIndex )
+                {
+                    case 0:
+                        aChild = new StringNode (xText.getText(), aParent);
+                        break;
+                    case 1:
+                        aChild = new StringNode ("# chars: " + xText.getCharacterCount(), aParent);
+                        break;
+                    case 2:
+                        aChild = new StringNode (characters( xText ), aParent);
+                        break;
+                    case 3:
+                        aChild = new StringNode ("selection: "
+                            + "[" + xText.getSelectionStart()
+                            + "," + xText.getSelectionEnd()
+                            + "] \"" + xText.getSelectedText() + "\"",
+                            aParent);
+                        break;
+                    case 4:
+                        aChild = new StringNode ("getCaretPosition: " + xText.getCaretPosition(), aParent);
+                        break;
+                    case 5:
+                        aChild = textAtIndexNode( xText, "Character",
+                            AccessibleTextType.CHARACTER,
+                            aParent);
+                        break;
+                    case 6:
+                        aChild = textAtIndexNode( xText, "Word",
+                            AccessibleTextType.WORD,
+                            aParent);
+                        break;
+                    case 7:
+                        aChild = textAtIndexNode( xText, "Sentence",
+                            AccessibleTextType.SENTENCE,
+                            aParent);
+                        break;
+                    case 8:
+                        aChild = textAtIndexNode( xText, "Paragraph",
+                            AccessibleTextType.PARAGRAPH,
+                            aParent);
+                        break;
+                    case 9:
+                        aChild = textAtIndexNode( xText, "Line",
+                            AccessibleTextType.LINE,
+                            aParent);
+                        break;
+                    case 10:
+                        aChild = textAtIndexNode( xText, "Attribute",
+                            (short)6/*AccessibleTextType.ATTRIBUTE*/,
+                            aParent);
+                        break;
+                    case 11:
+                        aChild = new StringNode (bounds( xText ), aParent);
+                        break;
+                    default:
+                        aChild = new StringNode ("unknown child index " + nIndex, aParent);
+                }
             }
         }
-        return aRet;
+        catch (Exception e)
+        {
+            // Return empty child.
+        }
+
+        return aChild;
     }
 
 
@@ -119,12 +155,13 @@ class AccessibleTextHandler extends NodeHandler
 
     /** Create a text node that lists all strings of a particular text type
      */
-    private Object textAtIndexNode(
+    private AccessibleTreeNode textAtIndexNode(
         XAccessibleText xText,
         String sName,
-        short nTextType)
+        short nTextType,
+        AccessibleTreeNode aParent)
     {
-        Vector aWords = new Vector();
+        VectorNode aNode = new VectorNode (sName, aParent);
 
         // get word at all positions;
         // for nicer display, compare current word to previous one and
@@ -149,8 +186,8 @@ class AccessibleTextHandler extends NodeHandler
                     if( ! ( sTmp.equals( sWord ) && sTBef.equals( sBefore ) &&
                             sTBeh.equals( sBehind ) ) )
                     {
-                        aWords.add( textAtIndexNodeString(
-                            nStart, i, sWord, sBefore, sBehind) );
+                        aNode.addChild (new StringNode (textAtIndexNodeString(
+                            nStart, i, sWord, sBefore, sBehind), aNode));
                         sWord = sTmp;
                         sBefore = sTBef;
                         sBehind = sTBeh;
@@ -158,24 +195,21 @@ class AccessibleTextHandler extends NodeHandler
                     }
 
                     // don't generate more than 50 children.
-                    if( aWords.size() > 50 )
+                    if (aNode.getChildCount() > 50)
                     {
                         sWord = "...";
                         break;
                     }
                 }
-                aWords.add( textAtIndexNodeString(
-                    nStart, nLength, sWord, sBefore, sBehind) );
+                aNode.addChild (new StringNode (textAtIndexNodeString(
+                    nStart, nLength, sWord, sBefore, sBehind), aNode));
             }
             catch( IndexOutOfBoundsException e )
             {
-                aWords.add( e.toString() );
+                aNode.addChild (new StringNode (e.toString(), aNode));
             }
         }
 
-        // create node, and add default handlers
-        AccTreeNode aNode = new AccTreeNode( aWords, sName );
-        AccessibilityTreeModel.addDefaultHandlers( aNode );
         return aNode;
     }
 
diff --git a/toolkit/test/accessibility/AccessibleTreeHandler.java b/toolkit/test/accessibility/AccessibleTreeHandler.java
index f3e3a65ce1ca..f734b14a5d19 100644
--- a/toolkit/test/accessibility/AccessibleTreeHandler.java
+++ b/toolkit/test/accessibility/AccessibleTreeHandler.java
@@ -1,3 +1,4 @@
+import drafts.com.sun.star.accessibility.XAccessible;
 import drafts.com.sun.star.accessibility.XAccessibleContext;
 import com.sun.star.uno.UnoRuntime;
 import com.sun.star.lang.IndexOutOfBoundsException;
@@ -7,36 +8,80 @@ import com.sun.star.lang.IndexOutOfBoundsException;
  * Map the tree of accessibility objects into their
  * AccessibilityTreeModel counterparts.
  */
-class AccessibleTreeHandler extends NodeHandler
+class AccessibleTreeHandler
+    extends NodeHandler
 {
-    protected XAccessibleContext getContext(Object aObject)
+    protected XAccessibleContext mxContext;
+
+    public NodeHandler createHandler (XAccessibleContext xContext)
+    {
+        if (xContext != null)
+            return new AccessibleTreeHandler (xContext);
+        else
+            return null;
+    }
+
+    public AccessibleTreeHandler ()
     {
-        XAccessibleContext xContext =
-            (XAccessibleContext) UnoRuntime.queryInterface (
-                 XAccessibleContext.class, aObject);
-        return xContext;
+        super();
+        mxContext = null;
     }
 
-    public int getChildCount(Object aObject)
+    public AccessibleTreeHandler (XAccessibleContext xContext)
     {
-        XAccessibleContext aContext = getContext(aObject);
-        return (aContext == null) ? 0 : aContext.getAccessibleChildCount();
+        super();
+        mxContext = xContext;
+        if (mxContext != null)
+            // Add one to the number of children to include the string node
+            // that tells you how many children there are.
+            maChildList.setSize (1 + mxContext.getAccessibleChildCount());
     }
 
-    public Object getChild(Object aObject, int nIndex)
+    public AccessibleTreeNode createChild (AccessibleTreeNode aParent, int nIndex)
     {
-        Object aRet = null;
-        XAccessibleContext aContext = getContext(aObject);
-        if( aContext != null )
+        AccessibleTreeNode aChild = null;
+        if (mxContext != null)
         {
-            try
+            if (nIndex == 0)
+                aChild = new StringNode ("Child count: " + mxContext.getAccessibleChildCount(),
+                    aParent);
+            else
             {
-                aRet = AccessibilityTreeModel.
-                    createDefaultNode(aContext.getAccessibleChild(nIndex));
+                // Lower index to skip the string node.
+                nIndex -= 1;
+                try
+                {
+                    XAccessible xChild = mxContext.getAccessibleChild (nIndex);
+                    aChild = AccessibilityTreeModel.createDefaultNode (
+                        xChild, aParent);
+                }
+                catch( IndexOutOfBoundsException e )
+                {
+                    aChild = new StringNode ("ERROR: no child with index " + nIndex, aParent);
+                }
             }
-            catch( IndexOutOfBoundsException e )
-            { } // return null
         }
-        return aRet;
+        else
+            aChild = new StringNode ("XAccessibleContext interface not supported", aParent);
+        return aChild;
     }
+
+    /** Try to add the specified accessible child into the lists of
+        children.  The insertion position is determined from the
+        getIndexInParent method of the child.
+    */
+    public AccessibleTreeNode addAccessibleChild (AccessibleTreeNode aParent, XAccessible xChild)
+    {
+        AccessibleTreeNode aChild = null;
+
+        XAccessibleContext xContext = xChild.getAccessibleContext();
+        int nIndex = xContext.getAccessibleIndexInParent() + 1;
+        if ((nIndex >= 0) || (nIndex <= maChildList.size()))
+        {
+            aChild = AccessibilityTreeModel.createDefaultNode (xChild, aParent);
+            maChildList.insertElementAt (aChild, nIndex);
+        }
+        return aChild;
+    }
+
 }
diff --git a/toolkit/test/accessibility/AccessibleTreeNode.java b/toolkit/test/accessibility/AccessibleTreeNode.java
new file mode 100644
index 000000000000..490530b3f5b3
--- /dev/null
+++ b/toolkit/test/accessibility/AccessibleTreeNode.java
@@ -0,0 +1,84 @@
+import java.util.Vector;
+import com.sun.star.lang.IndexOutOfBoundsException;
+
+/**
+    Base class for all tree nodes.
+ */
+class AccessibleTreeNode
+{
+    /// The parent node.  It is null for the root node.
+    protected AccessibleTreeNode maParent;
+
+    /// The object to be displayed.
+    private Object maDisplayObject;
+
+    public AccessibleTreeNode (Object aDisplayObject, AccessibleTreeNode aParent)
+    {
+        maDisplayObject = aDisplayObject;
+        maParent = aParent;
+    }
+
+    public void update ()
+    {
+        // Empty
+    }
+
+    public AccessibleTreeNode getParent ()
+    {
+        return maParent;
+    }
+
+    public Object getDisplayObject ()
+    {
+        return maDisplayObject;
+    }
+
+    public int getChildCount ()
+    {
+        return 0;
+    }
+
+    public AccessibleTreeNode getChild (int nIndex)
+        throws IndexOutOfBoundsException
+    {
+        throw new IndexOutOfBoundsException();
+    }
+
+    public boolean removeChild (int nIndex)
+        throws IndexOutOfBoundsException
+    {
+        throw new IndexOutOfBoundsException();
+    }
+
+    public int indexOf (AccessibleTreeNode aNode)
+    {
+        return -1;
+    }
+
+    /** Create a path to this node by first asking the parent for its path
+        and then appending this object.
+    */
+    public void createPath (java.util.Vector aPath)
+    {
+        if (maParent != null)
+            maParent.createPath (aPath);
+        aPath.add (this);
+    }
+
+    public Object[] createPath ()
+    {
+        Vector aPath = new Vector (1);
+        createPath (aPath);
+        return aPath.toArray();
+    }
+
+    public boolean isLeaf()
+    {
+        return true;
+    }
+
+    public String toString()
+    {
+        return maDisplayObject.toString();
+    }
+}
diff --git a/toolkit/test/accessibility/Canvas.java b/toolkit/test/accessibility/Canvas.java
index afacc0265330..ad72c3545cc7 100755
--- a/toolkit/test/accessibility/Canvas.java
+++ b/toolkit/test/accessibility/Canvas.java
@@ -172,34 +172,36 @@ class Canvas
 
     public void mouseMoved (MouseEvent e)
     {
-        maActiveObject = null;
-        for (int i=0; i<maObjects.size(); i++)
+        int nObjects = maObjects.size();
+        for (int i=nObjects-1; i>=0; i--)
         {
             AccessibleObject aObject = (AccessibleObject)(maObjects.elementAt(i));
             if (aObject != null)
             {
-                aObject.deselect ();
-                if (aObject != null)
-                    if (aObject.contains (e.getX(),e.getY()))
+                if (aObject.contains (e.getX(),e.getY()))
+                {
+                    if (aObject != maActiveObject)
                     {
+                        if (maActiveObject != null)
+                            maActiveObject.deselect();
+
                         maActiveObject = aObject;
-                    }
-            }
-        }
-        if (maActiveObject != null)
-        {
-            maActiveObject.select ();
-            maMessageDisplay.message ("mouse moved to " + e.getX() + "," + e.getY() + ": "
-                +maActiveObject.toString());
-            System.out.println ("path: " + maActiveObject.getPath());
+                        maMessageDisplay.message ("object under mouse is "
+                            +maActiveObject.toString());
+                        maActiveObject.select ();
 
-            if (maTree != null)
-            {
-                maTree.scrollPathToVisible (maActiveObject.getPath());
-                maTree.repaint ();
+                        if (maTree != null)
+                        {
+                            maTree.scrollPathToVisible (maActiveObject.getPath());
+                            maTree.repaint ();
+                        }
+
+                        repaint ();
+                    }
+                    break;
+                }
             }
         }
-        repaint ();
     }
 
     protected int
diff --git a/toolkit/test/accessibility/NodeHandler.java b/toolkit/test/accessibility/NodeHandler.java
index 3b1653ba34eb..4514207d6300 100644
--- a/toolkit/test/accessibility/NodeHandler.java
+++ b/toolkit/test/accessibility/NodeHandler.java
@@ -1,19 +1,85 @@
+import java.util.Vector;
+
+
 /**
  * Map an arbitrary object into parts of a tree node.
  */
 abstract class NodeHandler
 {
+    /** This vector is used as cache for the child objects.
+    */
+    protected Vector maChildList;
+
+
+    public abstract NodeHandler createHandler (
+        drafts.com.sun.star.accessibility.XAccessibleContext xContext);
+
+    public NodeHandler ()
+    {
+        maChildList = new Vector ();
+    }
+
+    /** Clear the cache of child objects.
+    */
+    public void clear ()
+    {
+        maChildList = new Vector ();
+    }
+
+    /** This factory method creates an individual handler for the specified
+        object that may hold information to accelerate the access to its children.
+    */
+    //    public abstract NodeHandler createHandler (Object aObject);
+
     /** return the number of children this object has */
-    public abstract int getChildCount(Object aObject);
+    public int getChildCount(Object aObject)
+    {
+        return maChildList.size();
+    }
 
     /**
-     * return a child object.
-     * You can use any object type for trivial nodes. Complex
+     * return a child object. Complex
      * children have to be AccTreeNode instances.
      * @see AccTreeNode
      */
-    public abstract Object getChild(Object aObject, int nIndex);
+    public AccessibleTreeNode getChild (AccessibleTreeNode aParent, int nIndex)
+    {
+        AccessibleTreeNode aChild = (AccessibleTreeNode)maChildList.get(nIndex);
+        if (aChild == null)
+        {
+            aChild = createChild (aParent, nIndex);
+            if (aChild == null)
+                aChild = new StringNode ("could not create child", aParent);
+            maChildList.setElementAt (aChild, nIndex);
+        }
+        return aChild;
+    }
+
+    /** Remove the specified child from the list of children.
+    */
+    public boolean removeChild (AccessibleTreeNode aNode, int nIndex)
+    {
+        try
+        {
+            maChildList.remove (nIndex);
+        }
+        catch (Exception e)
+        {
+            return false;
+        }
+        return true;
+    }
+
+    public int indexOf (AccessibleTreeNode aNode)
+    {
+        return maChildList.indexOf (aNode);
+    }
 
+    /** Create a child object for the specified data.  This method is called
+        usually from getChild and put there into the cache.
+    */
+    public abstract AccessibleTreeNode createChild (
+        AccessibleTreeNode aParent, int nIndex);
 
     //
     // The following methods support editing of children and actions.
@@ -27,7 +93,7 @@ abstract class NodeHandler
     }
 
     /** change this child's value */
-    public void setChild(Object aObject, int nIndex) { }
+    //    public void setChild(Object aObject, int nIndex) { }
 
 
     /** get names of suported actions */
@@ -37,5 +103,7 @@ abstract class NodeHandler
     }
 
     /** perform action */
-    public void performAction(Object aObject, int nIndex) { }
+    public void performAction(Object aObject, int nIndex)
+    {
+    }
 }
diff --git a/toolkit/test/accessibility/StringNode.java b/toolkit/test/accessibility/StringNode.java
new file mode 100644
index 000000000000..11a7286c60f1
--- /dev/null
+++ b/toolkit/test/accessibility/StringNode.java
@@ -0,0 +1,13 @@
+import com.sun.star.lang.IndexOutOfBoundsException;
+
+/**
+    Base class for all tree nodes.
+ */
+class StringNode
+    extends AccessibleTreeNode
+{
+    public StringNode (String aDisplayObject, AccessibleTreeNode aParent)
+    {
+        super (aDisplayObject, aParent);
+    }
+}
diff --git a/toolkit/test/accessibility/VectorNode.java b/toolkit/test/accessibility/VectorNode.java
new file mode 100644
index 000000000000..708fbda09d3a
--- /dev/null
+++ b/toolkit/test/accessibility/VectorNode.java
@@ -0,0 +1,50 @@
+import com.sun.star.lang.IndexOutOfBoundsException;
+import java.util.Vector;
+
+/**
+    Base class for all tree nodes.
+ */
+class VectorNode
+    extends StringNode
+{
+    private Vector maChildren;
+
+    public VectorNode (String sDisplayObject, AccessibleTreeNode aParent)
+    {
+        super (sDisplayObject, aParent);
+
+        maChildren = new Vector ();
+    }
+
+    public void addChild (AccessibleTreeNode aChild)
+    {
+        maChildren.add (aChild);
+    }
+
+    public int getChildCount ()
+    {
+        return maChildren.size();
+    }
+
+    public AccessibleTreeNode getChild (int nIndex)
+        throws IndexOutOfBoundsException
+    {
+        return (AccessibleTreeNode)maChildren.elementAt (nIndex);
+    }
+
+    public boolean removeChild (int nIndex)
+        throws IndexOutOfBoundsException
+    {
+        return maChildren.remove (nIndex) != null;
+    }
+
+    public int indexOf (AccessibleTreeNode aNode)
+    {
+        return maChildren.indexOf (aNode);
+    }
+
+    public boolean isLeaf()
+    {
+        return maChildren.isEmpty();
+    }
+}