toolkit/test/accessibility/NodeHandler.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 import java.util.Vector;
  20
  21
  22 /**
  23  * Map an arbitrary object into parts of a tree node.
  24  */
  25 abstract class NodeHandler
  26 {
  27     /** This vector is used as cache for the child objects.
  28     */
  29     protected Vector<AccessibleTreeNode> maChildList;
  30
  31
  32     public abstract NodeHandler createHandler (
  33         com.sun.star.accessibility.XAccessibleContext xContext);
  34
  35     public NodeHandler ()
  36     {
  37         maChildList = new Vector<AccessibleTreeNode> ();
  38     }
  39
  40     /** Clear the cache of child objects.
  41     */
  42     public void clear ()
  43     {
  44         synchronized (maChildList)
  45         {
  46             maChildList = new Vector<AccessibleTreeNode> ();
  47         }
  48     }
  49
  50     /** This factory method creates an individual handler for the specified
  51         object that may hold information to accelerate the access to its children.
  52     */
  53     //    public abstract NodeHandler createHandler (Object aObject);
  54
  55     /** return the number of children this object has */
  56     public int getChildCount(Object aObject)
  57     {
  58         synchronized (maChildList)
  59         {
  60             return maChildList.size();
  61         }
  62     }
  63
  64     /**
  65      * return a child object. Complex
  66      * children have to be AccTreeNode instances.
  67      * @see AccTreeNode
  68      */
  69     public AccessibleTreeNode getChild (AccessibleTreeNode aParent, int nIndex)
  70     {
  71         synchronized (maChildList)
  72         {
  73             AccessibleTreeNode aChild = maChildList.get(nIndex);
  74             if (aChild == null)
  75             {
  76                 aChild = createChild (aParent, nIndex);
  77                 if (aChild == null)
  78                     aChild = new StringNode ("could not create child", aParent);
  79                 maChildList.set (nIndex, aChild);
  80             }
  81             return aChild;
  82         }
  83     }
  84
  85     public AccessibleTreeNode getChildNoCreate (AccessibleTreeNode aParent, int nIndex)
  86     {
  87         synchronized (maChildList)
  88         {
  89             return maChildList.get(nIndex);
  90         }
  91     }
  92
  93     /** Remove the specified child from the list of children.
  94     */
  95     public boolean removeChild (AccessibleTreeNode aNode, int nIndex)
  96     {
  97         try
  98         {
  99             synchronized (maChildList)
 100             {
 101                 System.out.println ("    removing child at position " + nIndex + ": "
 102                     + maChildList.get (nIndex));
 103                 maChildList.remove (nIndex);
 104             }
 105         }
 106         catch (Exception e)
 107         {
 108             return false;
 109         }
 110         return true;
 111     }
 112
 113     public int indexOf (AccessibleTreeNode aNode)
 114     {
 115         synchronized (maChildList)
 116         {
 117             return maChildList.indexOf (aNode);
 118         }
 119     }
 120
 121     /** Create a child object for the specified data.  This method is called
 122         usually from getChild and put there into the cache.
 123     */
 124     public abstract AccessibleTreeNode createChild (
 125         AccessibleTreeNode aParent, int nIndex);
 126
 127     //
 128     // The following methods support editing of children and actions.
 129     // They have default implementations for no actions and read-only.
 130     //
 131
 132     /** May this child be changed? */
 133     public boolean isChildEditable (AccessibleTreeNode aNode, int nIndex)
 134     {
 135         return false;
 136     }
 137
 138     /** change this child's value */
 139     //    public void setChild(Object aObject, int nIndex) { }
 140
 141
 142     /** get names of suported actions */
 143     public String[] getActions (AccessibleTreeNode aNode)
 144     {
 145         return new String[] {};
 146     }
 147
 148     /** perform action */
 149     public void performAction (AccessibleTreeNode aNode, int nIndex)
 150     {
 151     }
 152
 153     /** Update all children.
 154     */
 155     public void update (AccessibleTreeNode aNode)
 156     {
 157     }
 158 }