summaryrefslogtreecommitdiff
path: root/toolkit/test/accessibility/AccessibilityTreeModel.java
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/test/accessibility/AccessibilityTreeModel.java')
-rw-r--r--toolkit/test/accessibility/AccessibilityTreeModel.java636
1 files changed, 324 insertions, 312 deletions
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 )
{
generated by cgit (git 2.34.1) at 2024-08-15 07:09:15 +0000